home *** CD-ROM | disk | FTP | other *** search
/ Mac Magazin/MacEasy 19 / Mac Magazin and MacEasy Magazine CD - Issue 19.iso / Utilities / uae-0.4 / Source Code / gencpu.c < prev    next >
Text File  |  1996-02-05  |  74KB  |  2,328 lines
  1. /* 
  2.  * UAE - The Un*x Amiga Emulator
  3.  *
  4.  * MC68000 emulation generator
  5.  *
  6.  * This is a fairly stupid program that generates a lot of case labels that 
  7.  * can be #included in a switch statement.
  8.  * As an alternative, it can generate functions that handle specific
  9.  * MC68000 instructions, plus a prototype header file and a function pointer
  10.  * array to look up the function for an opcode.
  11.  * Error checking is bad, an illegal table68k file will cause the program to
  12.  * call abort().
  13.  * The generated code is sometimes sub-optimal, an optimizing compiler should 
  14.  * take care of this.
  15.  * 
  16.  * (c) 1995 Bernd Schmidt
  17.  * 
  18.  */
  19.  
  20. #include <assert.h>
  21. #include <string.h>
  22. #include <stdio.h>
  23. #include <stdlib.h>
  24. #include <ctype.h>
  25.  
  26. #include "config.h"
  27. #include "amiga.h"
  28.  
  29. typedef enum {
  30.   Dreg, Areg, Aind, Aipi, Apdi, Ad16, Ad8r, 
  31.   absw, absl, PC16, PC8r, imm, imm0, imm1, imm2, immi, am_unknown, am_illg
  32. } amodes;
  33.  
  34. FILE *tablef;
  35. int nextch = 0;
  36.  
  37. typedef enum {
  38.     i_ILLG,
  39.     
  40.     i_OR, i_AND, i_EOR, i_ORSR, i_ANDSR, i_EORSR, 
  41.     i_SUB, i_SUBA, i_SUBX, i_SBCD, 
  42.     i_ADD, i_ADDA, i_ADDX, i_ABCD,
  43.     i_NEG, i_NEGX, i_NBCD, i_CLR, i_NOT, i_TST, 
  44.     i_BTST, i_BCHG, i_BCLR, i_BSET,
  45.     i_CMP, i_CMPM, i_CMPA, 
  46.     i_MOVEP, i_MOVE, i_MOVEA, i_MVSR2, i_MV2SR, 
  47.     i_SWAP, i_EXG, i_EXT, i_MVMEL, i_MVMLE, 
  48.     i_TRAP, i_MVR2USP, i_MVUSP2R, i_RESET, i_NOP, i_STOP, i_RTE, i_RTD, 
  49.     i_LINK, i_UNLK, 
  50.     i_RTS, i_TRAPV, i_RTR, 
  51.     i_JSR, i_JMP, i_BSR, i_Bcc,
  52.     i_LEA, i_PEA, i_DBcc, i_Scc, 
  53.     i_DIVU, i_DIVS, i_MULU, i_MULS, 
  54.     i_ASR, i_ASL, i_LSR, i_LSL, i_ROL, i_ROR, i_ROXL, i_ROXR,
  55.     i_ASRW, i_ASLW, i_LSRW, i_LSLW, i_ROLW, i_RORW, i_ROXLW, i_ROXRW
  56. } instrmnem;
  57.  
  58. struct mnemolookup {
  59.     instrmnem mnemo;
  60.     char name[10];
  61. } lookuptab[] = {
  62.     { i_OR, "OR" },
  63.     { i_AND, "AND" }, 
  64.     { i_EOR, "EOR" },
  65.     { i_ORSR, "ORSR" }, 
  66.     { i_ANDSR, "ANDSR" }, 
  67.     { i_EORSR, "EORSR" }, 
  68.     { i_SUB, "SUB" }, 
  69.     { i_SUBA, "SUBA" }, 
  70.     { i_SUBX, "SUBX" }, 
  71.     { i_SBCD, "SBCD" }, 
  72.     { i_ADD, "ADD" }, 
  73.     { i_ADDA, "ADDA" }, 
  74.     { i_ADDX, "ADDX" }, 
  75.     { i_ABCD, "ABCD" },
  76.     { i_NEG, "NEG" }, 
  77.     { i_NEGX, "NEGX" }, 
  78.     { i_NBCD, "NBCD" }, 
  79.     { i_CLR, "CLR" }, 
  80.     { i_NOT, "NOT" }, 
  81.     { i_TST, "TST" }, 
  82.     { i_BTST, "BTST" }, 
  83.     { i_BCHG, "BCHG" }, 
  84.     { i_BCLR, "BCLR" }, 
  85.     { i_BSET, "BSET" },
  86.     { i_CMP, "CMP" }, 
  87.     { i_CMPM, "CMPM" }, 
  88.     { i_CMPA, "CMPA" }, 
  89.     { i_MOVEP, "MOVEP" },
  90.     { i_MOVE, "MOVE" }, 
  91.     { i_MOVEA, "MOVEA" },
  92.     { i_MVSR2, "MVSR2" },
  93.     { i_MV2SR, "MV2SR" }, 
  94.     { i_SWAP, "SWAP" },
  95.     { i_EXG, "EXG" },
  96.     { i_EXT, "EXT" },
  97.     { i_MVMEL, "MVMEL" }, 
  98.     { i_MVMLE, "MVMLE" }, 
  99.     { i_TRAP, "TRAP" },
  100.     { i_MVR2USP, "MVR2USP" }, 
  101.     { i_MVUSP2R, "MVUSP2R" }, 
  102.     { i_RESET, "RESET" },
  103.     { i_NOP, "NOP" },
  104.     { i_STOP, "STOP" },
  105.     { i_RTE, "RTE" },
  106.     { i_RTD, "RTD" }, 
  107.     { i_LINK, "LINK" },
  108.     { i_UNLK, "UNLK" }, 
  109.     { i_RTS, "RTS" }, 
  110.     { i_TRAPV, "TRAPV" }, 
  111.     { i_RTR, "RTR" }, 
  112.     { i_JSR, "JSR" },
  113.     { i_JMP, "JMP" },
  114.     { i_BSR, "BSR" },
  115.     { i_Bcc, "Bcc" },
  116.     { i_LEA, "LEA" },
  117.     { i_PEA, "PEA" },
  118.     { i_DBcc, "DBcc" }, 
  119.     { i_Scc, "Scc" }, 
  120.     { i_DIVU, "DIVU" }, 
  121.     { i_DIVS, "DIVS" },
  122.     { i_MULU, "MULU" },
  123.     { i_MULS, "MULS" }, 
  124.     { i_ASR, "ASR" },
  125.     { i_ASL, "ASL" },
  126.     { i_LSR, "LSR" },
  127.     { i_LSL, "LSL" },
  128.     { i_ROL, "ROL" },
  129.     { i_ROR, "ROR" },
  130.     { i_ROXL, "ROXL" },
  131.     { i_ROXR, "ROXR" },
  132.     { i_ASRW, "ASRW" },
  133.     { i_ASLW, "ASLW" },
  134.     { i_LSRW, "LSRW" },
  135.     { i_LSLW, "LSLW" },
  136.     { i_ROLW, "ROLW" },
  137.     { i_RORW, "RORW" },
  138.     { i_ROXLW, "ROXLW" },
  139.     { i_ROXRW, "ROXRW" }
  140. };
  141.  
  142. char patbits[16];
  143. char opcstr[256];
  144.  
  145. UWORD bitmask,bitpattern;
  146.  
  147. typedef enum {
  148.     bit0, bit1, bitc, bitC, bitf, biti, bitI, bitj, bitJ, bits, bitS, bitd, bitD, bitr, bitR, bitz, lastbit
  149. } bitvals;
  150.  
  151. typedef enum {
  152.     sz_unknown, sz_byte, sz_word, sz_long
  153. } wordsizes;
  154.  
  155. struct instr {
  156.     instrmnem mnemo;
  157.     wordsizes size;
  158.     amodes dmode, smode;
  159.     unsigned char dreg;
  160.     unsigned char sreg;
  161.     unsigned int suse:1;
  162.     unsigned int duse:1;
  163.     unsigned int sbtarg:1;
  164.     unsigned int generated:1;
  165.     unsigned int cc:4;
  166.     signed char dpos;
  167.     signed char spos;
  168.     UWORD handler;
  169. } *table;
  170.  
  171. #ifdef DEBUG
  172. static void myabort(void)
  173. {
  174.     abort();
  175. }
  176. #else 
  177. #define myabort abort
  178. #endif
  179. static void getnextch(void)
  180. {
  181.     do {
  182.     nextch = fgetc(tablef);
  183.     if (nextch == '%') {
  184.         do {
  185.         nextch = fgetc(tablef);
  186.         } while (nextch != EOF && nextch != '\n');    
  187.     }
  188.     } while (nextch != EOF && isspace(nextch));    
  189. }
  190.  
  191. static void get_bits(void)
  192. {
  193.     int i;
  194.     
  195.     bitmask = bitpattern = 0;
  196.     for(i=0; i<16; i++) {
  197.     bitmask <<= 1;
  198.     bitpattern <<= 1;
  199.     if (nextch == '0' || nextch == '1') bitmask |= 1;
  200.     if (nextch == '1') bitpattern |= 1;
  201.     patbits[i] = nextch;
  202.     getnextch();
  203.     }
  204. }
  205.  
  206. static amodes mode_from_str(char *str)
  207. {
  208.     if (strncmp(str,"Dreg",4) == 0) return Dreg;
  209.     if (strncmp(str,"Areg",4) == 0) return Areg;
  210.     if (strncmp(str,"Aind",4) == 0) return Aind;
  211.     if (strncmp(str,"Apdi",4) == 0) return Apdi;
  212.     if (strncmp(str,"Aipi",4) == 0) return Aipi;
  213.     if (strncmp(str,"Ad16",4) == 0) return Ad16;
  214.     if (strncmp(str,"Ad8r",4) == 0) return Ad8r;
  215.     if (strncmp(str,"absw",4) == 0) return absw;
  216.     if (strncmp(str,"absl",4) == 0) return absl;
  217.     if (strncmp(str,"PC16",4) == 0) return PC16;
  218.     if (strncmp(str,"PC8r",4) == 0) return PC8r;
  219.     if (strncmp(str,"Immd",4) == 0) return imm;
  220.     myabort();
  221. }
  222.  
  223. static amodes mode_from_mr(int mode, int reg) 
  224. {
  225.     switch(mode) {
  226.      case 0: return Dreg; 
  227.      case 1: return Areg;
  228.      case 2: return Aind;
  229.      case 3: return Aipi;
  230.      case 4: return Apdi;
  231.      case 5: return Ad16;
  232.      case 6: return Ad8r;
  233.      case 7: 
  234.     switch(reg) {
  235.      case 0: return absw;
  236.      case 1: return absl;
  237.      case 2: return PC16;
  238.      case 3: return PC8r;
  239.      case 4: return imm;
  240.      case 5:
  241.      case 6:
  242.      case 7: return am_illg;
  243.     }
  244.     }
  245.     myabort();
  246. }
  247.  
  248. static void get_strs(void)
  249. {
  250.     fgets(opcstr, 250, tablef);
  251.     getnextch();
  252. }
  253.  
  254. static void parse_bits(void)
  255. {
  256.     int find;
  257.     long int opc;
  258.     
  259.     for(opc = 0; opc < 65536; opc ++) {
  260.     if ((opc & bitmask) == bitpattern) {
  261.         int bitcnt[lastbit];
  262.         int bitval[lastbit];
  263.         int bitpos[lastbit];
  264.         int i,j;
  265.         
  266.         UWORD msk = 0x8000;
  267.  
  268.         int pos = 0;
  269.  
  270.         int mnp = 0;
  271.         char mnemonic[10] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
  272.         wordsizes sz = sz_unknown;
  273.         bool srcgather = false, dstgather = false;
  274.         bool usesrc = false, usedst = false;
  275.         bool srcbtarg = false;
  276.         int srcpos, dstpos;
  277.         
  278.         amodes srcmode = am_unknown, destmode = am_unknown;
  279.         int srcreg, destreg;
  280.         
  281.         for(i=0; i < lastbit; i++) bitcnt[i] = bitval[i] = 0;
  282.  
  283.         for(j=0; j < 16; j++, msk >>= 1) {
  284.         bitvals currbit;
  285.         switch(patbits[j]) {
  286.          case '0': currbit = bit0; break;
  287.          case '1': currbit = bit1; break;
  288.          case 'c': currbit = bitc; break;
  289.          case 'C': currbit = bitC; break;
  290.          case 'f': currbit = bitf; break;
  291.          case 'i': currbit = biti; break;
  292.          case 'I': currbit = bitI; break;
  293.          case 'j': currbit = bitj; break;
  294.          case 'J': currbit = bitJ; break;
  295.          case 's': currbit = bits; break;
  296.          case 'S': currbit = bitS; break;
  297.          case 'd': currbit = bitd; break;
  298.          case 'D': currbit = bitD; break;
  299.          case 'r': currbit = bitr; break;
  300.          case 'R': currbit = bitR; break;
  301.          case 'z': currbit = bitz; break;
  302.          default: myabort();
  303.         }
  304.         bitpos[currbit] = 15 - j;
  305.         bitcnt[currbit]++;
  306.         bitval[currbit] = (bitval[currbit] << 1) | ((opc & msk) ? 1 : 0);
  307.         }
  308.         if (bitval[bitj] == 0) bitval[bitj] = 8;
  309.         /* first check whether this one does not match after all */
  310.         if (bitval[bitz] == 3) continue; 
  311.         if (bitval[bitC] == 1) continue;
  312.         if (bitcnt[bitI] && bitval[bitI] == 0) continue;
  313.  
  314.         /* bitI and bitC get copied to biti and bitc */
  315.         if (bitcnt[bitI]) { bitval[biti] = bitval[bitI]; bitpos[biti] = bitpos[bitI]; }
  316.         if (bitcnt[bitC]) bitval[bitc] = bitval[bitC];
  317.         
  318.         while (isspace(opcstr[pos]) || opcstr[pos] == ':') pos++;
  319.         while (!isspace(opcstr[pos])) {
  320.         if (opcstr[pos] == '.') {
  321.             pos++;
  322.             switch(opcstr[pos]) {
  323.             
  324.              case 'B': sz = sz_byte; break;
  325.              case 'W': sz = sz_word; break;
  326.              case 'L': sz = sz_long; break;
  327.              case 'z': 
  328.             switch(bitval[bitz]) {
  329.              case 0: sz = sz_byte; break;
  330.              case 1: sz = sz_word; break;
  331.              case 2: sz = sz_long; break;
  332.              default: myabort();
  333.             }
  334.             break;
  335.              default: myabort();
  336.             }
  337.         } else {            
  338.             mnemonic[mnp] = opcstr[pos];
  339.             if(mnemonic[mnp] == 'f') {
  340.             switch(bitval[bitf]) {
  341.              case 0: mnemonic[mnp] = 'R'; break;
  342.              case 1: mnemonic[mnp] = 'L'; break;
  343.              default: myabort();
  344.             }
  345.             }
  346.             mnp++;
  347.         }
  348.         pos++;        
  349.         }
  350.         
  351.         /* now, we have read the mnemonic and the size */
  352.         while (isspace(opcstr[pos])) pos++;
  353.         
  354.         /* A goto a day keeps the D******a away. */
  355.         if (opcstr[pos] == 0 || opcstr[pos] == ':') goto endofline;
  356.         
  357.         /* parse the source address */
  358.         usesrc = true;
  359.         switch(opcstr[pos++]) {
  360.          case 'D': 
  361.         srcmode = Dreg;
  362.         switch (opcstr[pos++]) {
  363.          case 'r': srcreg = bitval[bitr]; srcgather = true; srcpos = bitpos[bitr]; break;
  364.          case 'R': srcreg = bitval[bitR]; srcgather = true; srcpos = bitpos[bitR]; break;
  365.          default: myabort();
  366.         }
  367.         
  368.         break;
  369.          case 'A': 
  370.         srcmode = Areg;
  371.         switch (opcstr[pos++]) {
  372.          case 'r': srcreg = bitval[bitr]; srcgather = true; srcpos = bitpos[bitr]; break;
  373.          case 'R': srcreg = bitval[bitR]; srcgather = true; srcpos = bitpos[bitR]; break;
  374.          default: myabort();
  375.         }
  376.         switch (opcstr[pos]) {
  377.          case 'p': srcmode = Apdi; pos++; break;
  378.          case 'P': srcmode = Aipi; pos++; break;
  379.         }
  380.         break;
  381.          case '#':
  382.         switch(opcstr[pos++]) {
  383.          case 'z': srcmode = imm; break;
  384.          case '0': srcmode = imm0; break;
  385.          case '1': srcmode = imm1; break;
  386.          case '2': srcmode = imm2; break;
  387.          case 'i': srcmode = immi; srcreg = (LONG)(BYTE)bitval[biti]; srcbtarg = true; srcgather = true; srcpos = bitpos[biti]; break;
  388.          case 'j': srcmode = immi; srcreg = bitval[bitj]; break;
  389.          case 'J': srcmode = immi; srcreg = bitval[bitJ]; break;
  390.          default: myabort();
  391.         }
  392.         break;
  393.          case 'd':
  394.         srcreg = bitval[bitD];
  395.         srcmode = mode_from_mr(bitval[bitd],bitval[bitD]);
  396.         if (srcmode == am_illg) continue;
  397.         if (srcmode == Areg || srcmode == Dreg || srcmode == Aind 
  398.             || srcmode == Ad16 || srcmode == Ad8r || srcmode == Aipi
  399.             || srcmode == Apdi)
  400.         {
  401.             srcgather = true; srcpos = bitpos[bitD];
  402.         }
  403.         if (opcstr[pos] == '[') {
  404.             pos++;
  405.             if (opcstr[pos] == '!') {
  406.             /* exclusion */
  407.             do {                
  408.                 pos++;
  409.                 if (mode_from_str(opcstr+pos) == srcmode) goto nomatch;
  410.                 pos += 4;                
  411.             } while (opcstr[pos] == ',');
  412.             pos++;
  413.             } else {
  414.             if (opcstr[pos+4] == '-') {
  415.                 /* replacement */
  416.                 if (mode_from_str(opcstr+pos) == srcmode) 
  417.                     srcmode = mode_from_str(opcstr+pos+5);
  418.                 else
  419.                     goto nomatch;
  420.                 pos += 10;
  421.             } else {
  422.                 /* normal */
  423.                 while(mode_from_str(opcstr+pos) != srcmode) {
  424.                 pos += 4;
  425.                 if (opcstr[pos] == ']') goto nomatch;
  426.                 pos++;
  427.                 }
  428.                 while(opcstr[pos] != ']') pos++;
  429.                 pos++;
  430.                 break;
  431.             }
  432.             }
  433.         }
  434.         /* Some addressing modes are invalid as destination */
  435.         if (srcmode == imm || srcmode == PC16 || srcmode == PC8r)
  436.             goto nomatch; 
  437.         break;
  438.          case 's':
  439.         srcreg = bitval[bitS];
  440.         srcmode = mode_from_mr(bitval[bits],bitval[bitS]);
  441.         
  442.         if(srcmode == am_illg) continue;            
  443.         if (srcmode == Areg || srcmode == Dreg || srcmode == Aind 
  444.             || srcmode == Ad16 || srcmode == Ad8r || srcmode == Aipi
  445.             || srcmode == Apdi)
  446.         {
  447.             srcgather = true; srcpos = bitpos[bitS];
  448.         }
  449.         if (opcstr[pos] == '[') {
  450.             pos++;
  451.             if (opcstr[pos] == '!') {
  452.             /* exclusion */
  453.             do {                
  454.                 pos++;
  455.                 if (mode_from_str(opcstr+pos) == srcmode) goto nomatch;
  456.                 pos += 4;                
  457.             } while (opcstr[pos] == ',');
  458.             pos++;
  459.             } else {
  460.             if (opcstr[pos+4] == '-') {
  461.                 /* replacement */
  462.                 if (mode_from_str(opcstr+pos) == srcmode) 
  463.                     srcmode = mode_from_str(opcstr+pos+5);
  464.                 else
  465.                     goto nomatch;
  466.                 pos += 10;
  467.             } else {
  468.                 /* normal */
  469.                 while(mode_from_str(opcstr+pos) != srcmode) {
  470.                 pos += 4;
  471.                 if (opcstr[pos] == ']') goto nomatch;
  472.                 pos++;
  473.                 }
  474.                 while(opcstr[pos] != ']') pos++;
  475.                 pos++;
  476.             }
  477.             }
  478.         }
  479.         break;
  480.          default: myabort();
  481.         }
  482.         /* safety check - might have changed */
  483.         if (srcmode != Areg && srcmode != Dreg && srcmode != Aind 
  484.         && srcmode != Ad16 && srcmode != Ad8r && srcmode != Aipi
  485.         && srcmode != Apdi && srcmode != immi)
  486.         {
  487.         srcgather = false;
  488.         }
  489.         if (srcmode == Areg && sz == sz_byte)
  490.             goto nomatch;
  491.         
  492.         if (opcstr[pos] != ',') goto endofline;
  493.         pos++;
  494.         
  495.         /* parse the destination address */
  496.         usedst = true;        
  497.         switch(opcstr[pos++]) {
  498.          case 'D': 
  499.         destmode = Dreg;
  500.         switch (opcstr[pos++]) {
  501.          case 'r': destreg = bitval[bitr]; dstgather = true; dstpos = bitpos[bitr]; break;
  502.          case 'R': destreg = bitval[bitR]; dstgather = true; dstpos = bitpos[bitR]; break;
  503.          default: myabort();
  504.         }
  505.         break;
  506.          case 'A': 
  507.         destmode = Areg;
  508.         switch (opcstr[pos++]) {
  509.          case 'r': destreg = bitval[bitr]; dstgather = true; dstpos = bitpos[bitr]; break;
  510.          case 'R': destreg = bitval[bitR]; dstgather = true; dstpos = bitpos[bitR]; break;
  511.          default: myabort();
  512.         }
  513.         switch (opcstr[pos]) {
  514.          case 'p': destmode = Apdi; pos++; break;
  515.          case 'P': destmode = Aipi; pos++; break;
  516.         }
  517.         break;
  518.          case '#':
  519.         switch(opcstr[pos++]) {
  520.          case 'z': destmode = imm; break;
  521.          case '0': destmode = imm0; break;
  522.          case '1': destmode = imm1; break;
  523.          case '2': destmode = imm2; break;
  524.          case 'i': destmode = immi; destreg = (LONG)(BYTE)bitval[biti]; break;
  525.          case 'j': destmode = immi; destreg = bitval[bitj]; break;
  526.          case 'J': destmode = immi; destreg = bitval[bitJ]; break;
  527.          default: myabort();
  528.         }
  529.         break;
  530.          case 'd':
  531.         destreg = bitval[bitD];
  532.         destmode = mode_from_mr(bitval[bitd],bitval[bitD]);
  533.         if(destmode == am_illg) continue;
  534.         if (destmode == Areg || destmode == Dreg || destmode == Aind 
  535.             || destmode == Ad16 || destmode == Ad8r || destmode == Aipi
  536.             || destmode == Apdi)
  537.         {
  538.             dstgather = true; dstpos = bitpos[bitD];
  539.         }
  540.         
  541.         if (opcstr[pos] == '[') {
  542.             pos++;
  543.             if (opcstr[pos] == '!') {
  544.             /* exclusion */
  545.             do {                
  546.                 pos++;
  547.                 if (mode_from_str(opcstr+pos) == destmode) goto nomatch;
  548.                 pos += 4;                
  549.             } while (opcstr[pos] == ',');
  550.             pos++;
  551.             } else {
  552.             if (opcstr[pos+4] == '-') {
  553.                 /* replacement */
  554.                 if (mode_from_str(opcstr+pos) == destmode) 
  555.                     destmode = mode_from_str(opcstr+pos+5);
  556.                 else
  557.                     goto nomatch;
  558.                 pos += 10;
  559.             } else {
  560.                 /* normal */
  561.                 while(mode_from_str(opcstr+pos) != destmode) {
  562.                 pos += 4;
  563.                 if (opcstr[pos] == ']') goto nomatch;
  564.                 pos++;
  565.                 }
  566.                 while(opcstr[pos] != ']') pos++;
  567.                 pos++;
  568.                 break;
  569.             }
  570.             }
  571.         }
  572.         /* Some addressing modes are invalid as destination */
  573.         if (destmode == imm || destmode == PC16 || destmode == PC8r)
  574.             goto nomatch;
  575.         break;
  576.          case 's':
  577.         destreg = bitval[bitS];
  578.         destmode = mode_from_mr(bitval[bits],bitval[bitS]);
  579.         
  580.         if(destmode == am_illg) continue;            
  581.         if (destmode == Areg || destmode == Dreg || destmode == Aind 
  582.             || destmode == Ad16 || destmode == Ad8r || destmode == Aipi
  583.             || destmode == Apdi)
  584.         {
  585.             dstgather = true; dstpos = bitpos[bitS];
  586.         }
  587.         
  588.         if (opcstr[pos] == '[') {
  589.             pos++;
  590.             if (opcstr[pos] == '!') {
  591.             /* exclusion */
  592.             do {                
  593.                 pos++;
  594.                 if (mode_from_str(opcstr+pos) == destmode) goto nomatch;
  595.                 pos += 4;                
  596.             } while (opcstr[pos] == ',');
  597.             pos++;
  598.             } else {
  599.             if (opcstr[pos+4] == '-') {
  600.                 /* replacement */
  601.                 if (mode_from_str(opcstr+pos) == destmode) 
  602.                     destmode = mode_from_str(opcstr+pos+5);
  603.                 else
  604.                     goto nomatch;
  605.                 pos += 10;
  606.             } else {
  607.                 /* normal */
  608.                 while(mode_from_str(opcstr+pos) != destmode) {
  609.                 pos += 4;
  610.                 if (opcstr[pos] == ']') goto nomatch;
  611.                 pos++;
  612.                 }
  613.                 while(opcstr[pos] != ']') pos++;
  614.                 pos++;
  615.             }
  616.             }
  617.         }
  618.         break;
  619.          default: myabort();
  620.         }
  621.         /* safety check - might have changed */
  622.         if (destmode != Areg && destmode != Dreg && destmode != Aind 
  623.         && destmode != Ad16 && destmode != Ad8r && destmode != Aipi
  624.         && destmode != Apdi)
  625.         {
  626.         dstgather = false;
  627.         }
  628.         
  629.         if (destmode == Areg && sz == sz_byte)
  630.             goto nomatch;
  631. #if 0
  632.         if (sz == sz_byte && (destmode == Aipi || destmode == Apdi)) {
  633.         dstgather = false;
  634.         }
  635. #endif
  636. endofline:
  637.         /* now, we have a match */
  638.         if (table[opc].mnemo != i_ILLG)
  639.             fprintf(stderr, "Double match: %x: %s\n", opc, opcstr);
  640.         for(find = 0;; find++) {
  641.         if (strcmp(mnemonic, lookuptab[find].name) == 0) {
  642.             table[opc].mnemo = lookuptab[find].mnemo;
  643.             break;
  644.         }
  645.         if (strlen(lookuptab[find].name) == 0) myabort();
  646.         }
  647.         table[opc].cc = bitval[bitc];
  648.         if (table[opc].mnemo == i_BTST
  649.         || table[opc].mnemo == i_BSET
  650.         || table[opc].mnemo == i_BCLR
  651.         || table[opc].mnemo == i_BCHG) 
  652.         {
  653.         sz = destmode == Dreg ? sz_long : sz_byte;
  654.         }
  655.         table[opc].generated = false;
  656.         table[opc].size = sz;
  657.         table[opc].sreg = srcreg;
  658.         table[opc].dreg = destreg;
  659.         table[opc].smode = srcmode;
  660.         table[opc].dmode = destmode;
  661.         table[opc].spos = srcgather ? srcpos : -1;
  662.         table[opc].dpos = dstgather ? dstpos : -1;
  663.         table[opc].suse = usesrc;
  664.         table[opc].duse = usedst;
  665.         table[opc].sbtarg = srcbtarg;
  666. nomatch:
  667.         /* FOO! */;
  668.     }
  669.     }
  670. }
  671.  
  672. static int n_braces = 0;
  673.  
  674. static void start_brace(void)
  675. {
  676.     n_braces++;
  677.     printf("{");
  678. }
  679.  
  680. static void close_brace(void)
  681. {
  682.     assert (n_braces > 0);
  683.     n_braces--;
  684.     printf("}");
  685. }
  686.  
  687. static void finish_braces(void)
  688. {
  689.     while (n_braces > 0)
  690.     close_brace();
  691. }
  692.  
  693. static void pop_braces(int to)
  694. {
  695.     while (n_braces > to)
  696.     close_brace();
  697. }
  698.  
  699. static void genamode(amodes mode, char *reg, wordsizes size, char *name, bool getv, bool movem)
  700. {
  701.     start_brace ();
  702.     switch(mode) {
  703.      case Dreg:
  704.     if (movem)
  705.         abort();
  706.     if (getv)
  707.         switch(size) {      
  708.          case sz_byte:
  709.         printf("\tBYTE %s = regs.d[%s];\n", name, reg);
  710.         break;
  711.          case sz_word:
  712.         printf("\tWORD %s = regs.d[%s];\n", name, reg);
  713.         break;
  714.          case sz_long:
  715.         printf("\tLONG %s = regs.d[%s];\n", name, reg);
  716.         break;
  717.          default: myabort();
  718.         }
  719.     break;
  720.      case Areg:
  721.     if (movem)
  722.         abort();
  723.     if (getv)
  724.         switch(size) {      
  725.          case sz_word:
  726.         printf("\tWORD %s = regs.a[%s];\n", name, reg);
  727.         break;
  728.          case sz_long:
  729.         printf("\tLONG %s = regs.a[%s];\n", name, reg);
  730.         break;
  731.          default: myabort();
  732.         }
  733.     break;
  734.      case Aind:
  735.     printf("\tCPTR %sa = regs.a[%s];\n", name, reg);
  736.     if (getv)
  737.         switch(size) {      
  738.          case sz_byte:
  739.         printf("\tBYTE %s = get_byte(%sa);\n", name, name);
  740.         break;
  741.          case sz_word:
  742.         printf("\tWORD %s = get_word(%sa);\n", name, name);
  743.         break;
  744.          case sz_long:
  745.         printf("\tLONG %s = get_long(%sa);\n", name, name);
  746.         break;
  747.          default: myabort();
  748.         }
  749.     break;
  750.      case Aipi:
  751.     printf("\tCPTR %sa = regs.a[%s];\n", name, reg);
  752.     switch(size) {
  753.      case sz_byte:        
  754.         if (getv) printf("\tBYTE %s = get_byte(%sa);\n", name, name);
  755.         if (!movem) {
  756.         start_brace();
  757.         printf("\tregs.a[%s] += (%s == 7) ? 2 : 1;\n", reg, reg);
  758.         }
  759.         break;
  760.      case sz_word:
  761.         if (getv) printf("\tWORD %s = get_word(%sa);\n", name, name);
  762.         if (!movem) {
  763.         start_brace();
  764.         printf("\tregs.a[%s] += 2;\n", reg);
  765.         }
  766.         break;
  767.      case sz_long:
  768.         if (getv) printf("\tLONG %s = get_long(%sa);\n", name, name);
  769.         if (!movem) {
  770.         start_brace();
  771.         printf("\tregs.a[%s] += 4;\n", reg);
  772.         }
  773.         break;
  774.      default: myabort();
  775.     }
  776.     break;
  777.      case Apdi:
  778.     switch(size) {      
  779.      case sz_byte:
  780.         if (!movem) printf("\tregs.a[%s] -= (%s == 7) ? 2 : 1;\n", reg, reg);
  781.         start_brace();
  782.         printf("\tCPTR %sa = regs.a[%s];\n", name, reg);
  783.         if (getv) printf("\tBYTE %s = get_byte(%sa);\n", name, name);
  784.         break;
  785.      case sz_word:
  786.         if (!movem) printf("\tregs.a[%s] -= 2;\n", reg);
  787.         start_brace();
  788.         printf("\tCPTR %sa = regs.a[%s];\n", name, reg);
  789.         if (getv) printf("\tWORD %s = get_word(%sa);\n", name, name);
  790.         break;
  791.      case sz_long:
  792.         if (!movem) printf("\tregs.a[%s] -= 4;\n", reg);
  793.         start_brace();
  794.         printf("\tCPTR %sa = regs.a[%s];\n", name, reg);
  795.         if (getv) printf("\tLONG %s = get_long(%sa);\n", name, name);
  796.         break;
  797.      default: myabort();
  798.     }
  799.     break;
  800.      case Ad16:
  801.     printf("\tCPTR %sa = regs.a[%s] + (LONG)(WORD)nextiword();\n", name, reg);
  802.     if (getv) 
  803.         switch(size) {      
  804.          case sz_byte:
  805.         printf("\tBYTE %s = get_byte(%sa);\n", name, name);
  806.         break;
  807.          case sz_word:
  808.         printf("\tWORD %s = get_word(%sa);\n", name, name);
  809.         break;
  810.          case sz_long:
  811.         printf("\tLONG %s = get_long(%sa);\n", name, name);
  812.         break;
  813.          default: myabort();
  814.         }
  815.     break;
  816.      case Ad8r:
  817.     printf("\tCPTR %sa = regs.a[%s];\n", name, reg);
  818.     printf("\tUWORD %sdp = nextiword();\n", name);
  819.     printf("\t%sa += (LONG)(BYTE)(%sdp & 0xFF);\n", name, name);
  820.     start_brace();
  821.     printf("\tULONG %sdpr = %sdp & 0x8000 ? regs.a[(%sdp & 0x7000) >> 12] : regs.d[(%sdp & 0x7000) >> 12];\n", name, name, name, name);
  822.     printf("\tif (!(%sdp & 0x800)) %sdpr = (LONG)(WORD)%sdpr;\n", name, name, name);
  823.     printf("\t%sa += %sdpr;\n", name, name);
  824.     if (getv) {
  825.         start_brace();
  826.         switch(size) {      
  827.          case sz_byte:
  828.         printf("\tBYTE %s = get_byte(%sa);\n", name, name);
  829.         break;
  830.          case sz_word:
  831.         printf("\tWORD %s = get_word(%sa);\n", name, name);
  832.         break;
  833.          case sz_long:
  834.         printf("\tLONG %s = get_long(%sa);\n", name, name);
  835.         break;
  836.          default: myabort();
  837.         }
  838.     }
  839.     break;
  840.      case PC16:
  841.     printf("\tCPTR %sa = m68k_getpc();\n", name);
  842.     printf("\t%sa += (LONG)(WORD)nextiword();\n", name);
  843.     if (getv) {
  844.         start_brace();
  845.         switch(size) {      
  846.          case sz_byte:
  847.         printf("\tBYTE %s = get_byte(%sa);\n", name, name);
  848.         break;
  849.          case sz_word:
  850.         printf("\tWORD %s = get_word(%sa);\n", name, name);
  851.         break;
  852.          case sz_long:
  853.         printf("\tLONG %s = get_long(%sa);\n", name, name);
  854.         break;
  855.          default: myabort();
  856.         }
  857.     }
  858.     break;
  859.      case PC8r:
  860.     printf("\tCPTR %sa = m68k_getpc();\n", name);
  861.     printf("\tUWORD %sdp = nextiword();\n", name);
  862.     printf("\t%sa += (LONG)(BYTE)(%sdp & 0xFF);\n", name, name);
  863.     start_brace();
  864.     printf("\tULONG %sdpr = %sdp & 0x8000 ? regs.a[(%sdp & 0x7000) >> 12] : regs.d[(%sdp & 0x7000) >> 12];\n", name, name, name, name);
  865.     printf("\tif (!(%sdp & 0x800)) %sdpr = (LONG)(WORD)%sdpr;\n", name, name, name);
  866.     printf("\t%sa += %sdpr;\n", name, name);
  867.     if (getv) {
  868.         start_brace();
  869.         switch(size) {      
  870.          case sz_byte:
  871.         printf("\tBYTE %s = get_byte(%sa);\n", name, name);
  872.         break;
  873.          case sz_word:
  874.         printf("\tWORD %s = get_word(%sa);\n", name, name);
  875.         break;
  876.          case sz_long:
  877.         printf("\tLONG %s = get_long(%sa);\n", name, name);
  878.         break;
  879.          default: myabort();
  880.         }
  881.     }
  882.     break;
  883.      case absw:
  884.     printf("\tCPTR %sa = (LONG)(WORD)nextiword();\n", name);
  885.     if (getv) 
  886.         switch(size) {      
  887.          case sz_byte:
  888.         printf("\tBYTE %s = get_byte(%sa);\n", name, name);
  889.         break;
  890.          case sz_word:
  891.         printf("\tWORD %s = get_word(%sa);\n", name, name);
  892.         break;
  893.          case sz_long:
  894.         printf("\tLONG %s = get_long(%sa);\n", name, name);
  895.         break;
  896.          default: myabort();
  897.         }
  898.     break;
  899.      case absl:
  900.     printf("\tCPTR %sa = nextilong();\n", name);
  901.     if (getv) 
  902.         switch(size) {      
  903.          case sz_byte:
  904.         printf("\tBYTE %s = get_byte(%sa);\n", name, name);
  905.         break;
  906.          case sz_word:
  907.         printf("\tWORD %s = get_word(%sa);\n", name, name);
  908.         break;
  909.          case sz_long:
  910.         printf("\tLONG %s = get_long(%sa);\n", name, name);
  911.         break;
  912.          default: myabort();
  913.         }
  914.     break;
  915.      case imm:
  916.     if (getv) 
  917.         switch(size) {
  918.          case sz_byte:
  919.         printf("\tBYTE %s = nextiword();\n", name);
  920.         break;
  921.          case sz_word:
  922.         printf("\tWORD %s = nextiword();\n", name);
  923.         break;
  924.          case sz_long:
  925.         printf("\tLONG %s = nextilong();\n", name);
  926.         break;
  927.          default: myabort();
  928.         }
  929.     break;
  930.      case imm0:
  931.     if (!getv) myabort();
  932.     printf("\tBYTE %s = nextiword();\n", name);
  933.     break;
  934.      case imm1:
  935.     if (!getv) myabort();
  936.     printf("\tWORD %s = nextiword();\n", name);
  937.     break;
  938.      case imm2:
  939.     if (!getv) myabort();
  940.         printf("\tLONG %s = nextilong();\n", name);
  941.     break;
  942.      case immi:
  943.     if (!getv) myabort();
  944.     printf("\tULONG %s = %s;\n", name, reg);
  945.     break;
  946.      default: 
  947.     myabort();
  948.     }
  949. }
  950.  
  951. static void genastore(char *from, amodes mode, char *reg, wordsizes size, char *to)
  952. {
  953.     switch(mode) {
  954.      case Dreg:
  955.     switch(size) {      
  956.      case sz_byte:
  957.         printf("\tregs.d[%s] &= ~0xff; regs.d[%s] |= (%s) & 0xff;\n", reg, reg, from);
  958.         break;
  959.      case sz_word:
  960.         printf("\tregs.d[%s] &= ~0xffff; regs.d[%s] |= (%s) & 0xffff;\n", reg, reg, from);
  961.         break;
  962.      case sz_long:
  963.         printf("\tregs.d[%s] = (%s);\n", reg, from);
  964.         break;
  965.      default: myabort();
  966.     }
  967.     break;
  968.      case Areg:
  969.     switch(size) {      
  970.      case sz_word:
  971.         printf("\tregs.a[%s] = (LONG)(WORD)(%s);\n", reg, from);
  972.         break;
  973.      case sz_long:
  974.         printf("\tregs.a[%s] = (%s);\n", reg, from);
  975.         break;
  976.      default: myabort();
  977.     }
  978.     break;
  979.      case Aind:
  980.      case Aipi:
  981.      case Apdi:
  982.      case Ad16:
  983.      case Ad8r:
  984.      case absw:
  985.      case absl:
  986.     switch(size) {
  987.      case sz_byte:
  988.         printf("\tput_byte(%sa,%s);\n", to, from);
  989.         break;
  990.      case sz_word:
  991.         printf("\tput_word(%sa,%s);\n", to, from);
  992.         break;
  993.      case sz_long:
  994.         printf("\tput_long(%sa,%s);\n", to, from);
  995.         break;
  996.      default: myabort();
  997.     }
  998.     break;
  999.      case PC16:
  1000.      case PC8r:
  1001.     switch(size) {
  1002.      case sz_byte:
  1003.         printf("\tput_byte(%sa,%s);\n", to, from);
  1004.         break;
  1005.         /* These are only used for byte-sized bit ops */
  1006.      default: myabort();
  1007.     }
  1008.     break;
  1009.      case imm:
  1010.      case imm0:
  1011.      case imm1:
  1012.      case imm2:
  1013.      case immi:
  1014.     myabort();
  1015.     break;
  1016.      default: 
  1017.     myabort();
  1018.     }
  1019. }
  1020.  
  1021. static void genmovemel(UWORD opcode)
  1022. {
  1023.     char getcode[100];
  1024.     int size = table[opcode].size == sz_long ? 4 : 2;
  1025.     
  1026.     if (table[opcode].size == sz_long) {    
  1027.         strcpy(getcode, "get_long(srca)");
  1028.     } else {        
  1029.         strcpy(getcode, "(LONG)(WORD)get_word(srca)");
  1030.     }
  1031.     
  1032.     printf("\tUWORD mask = nextiword(), bitmask = mask;\n");
  1033.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "src", false, true);
  1034.     start_brace();
  1035.     printf("\tint i, bitcnt = 0;\n");
  1036.     printf("\tfor(i=0;i<16;i++) { bitcnt += bitmask & 1; bitmask >>= 1; }\n");
  1037.     
  1038.     printf("\tfor(i=0;i<8;i++) { if (mask & 1) { regs.d[i] = %s; srca += %d; } mask >>= 1; }\n", getcode, size);
  1039.     printf("\tfor(i=0;i<8;i++) { if (mask & 1) { regs.a[i] = %s; srca += %d; } mask >>= 1; }\n", getcode, size);
  1040.     
  1041.     if (table[opcode].smode == Aipi)
  1042.         printf("\tregs.a[srcreg] = srca;\n");
  1043. }
  1044.  
  1045. static void genmovemle(UWORD opcode)
  1046. {
  1047.     char putcode[100], shiftcode[] = ">>";
  1048.     int size = table[opcode].size == sz_long ? 4 : 2;
  1049.     int mask = 1;
  1050.     if (table[opcode].size == sz_long) {
  1051.         strcpy(putcode, "put_long(srca,");
  1052.     } else {        
  1053.         strcpy(putcode, "put_word(srca,");
  1054.     }
  1055.     
  1056.     printf("\tUWORD mask = nextiword(), bitmask = mask;\n");
  1057.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "src", false, true);
  1058.     start_brace();
  1059.     printf("\tint i, bitcnt = 0;\n");
  1060.     printf("\tULONG rd[8], ra[8];\n");
  1061.     printf("\tfor(i=0;i<16;i++) { bitcnt += bitmask & 1; bitmask >>= 1; }\n");
  1062.     printf("\tfor(i=0;i<8;i++) { rd[i] = regs.d[i]; ra[i] = regs.a[i]; }\n");
  1063.     if (table[opcode].smode == Apdi) {
  1064.     printf("\tsrca -= %d*bitcnt;\n", size);
  1065.     printf("\tregs.a[srcreg] = srca;\n");
  1066.     strcpy(shiftcode, "<<");
  1067.     mask = 0x8000;
  1068.     }
  1069.  
  1070.     printf("\tfor(i=0;i<8;i++) { if (mask & %d) { %s rd[i]); srca += %d; } mask %s= 1; }\n", 
  1071.        mask, putcode, size, shiftcode);
  1072.     printf("\tfor(i=0;i<8;i++) { if (mask & %d) { %s ra[i]); srca += %d; } mask %s= 1; }\n",
  1073.        mask, putcode, size, shiftcode);    
  1074. }
  1075.  
  1076. typedef enum {
  1077.     flag_logical, flag_add, flag_sub, flag_cmp, flag_addx, flag_subx, flag_zn
  1078. } flagtypes;
  1079.  
  1080. static void genflags(flagtypes type, wordsizes size, char *value, char *src, char *dst)
  1081. {
  1082.     char vstr[100],sstr[100],dstr[100];
  1083.     char usstr[100],udstr[100];
  1084.     char unsstr[100],undstr[100];
  1085.     ULONG mask;
  1086.     switch(size) {
  1087.      case sz_byte: mask = 0xFF; break;
  1088.      case sz_word: mask = 0xFFFF; break;
  1089.      case sz_long: mask = 0xFFFFFFFF; break;
  1090.      default: myabort();
  1091.     }
  1092. #ifndef NO_INLINE_FLAGS
  1093.     switch(size) {        
  1094.      case sz_byte:
  1095.     strcpy(vstr, "((BYTE)(");
  1096.     strcpy(usstr, "((UBYTE)(");
  1097.     break;
  1098.      case sz_word:
  1099.     strcpy(vstr, "((WORD)(");
  1100.     strcpy(usstr, "((UWORD)(");
  1101.     break;
  1102.      case sz_long:
  1103.     strcpy(vstr, "((LONG)(");
  1104.     strcpy(usstr, "((ULONG)(");
  1105.     break;
  1106.      default:
  1107.     myabort();
  1108.     }
  1109.     strcpy(unsstr, usstr); 
  1110.  
  1111.     strcpy(sstr, vstr);
  1112.     strcpy(dstr, vstr);
  1113.     strcat(vstr, value); strcat(vstr,"))");
  1114.     strcat(dstr, dst); strcat(dstr,"))");
  1115.     strcat(sstr, src); strcat(sstr,"))");
  1116.     
  1117.     strcpy(udstr, usstr);
  1118.     strcat(udstr, dst); strcat(udstr,"))");
  1119.     strcat(usstr, src); strcat(usstr,"))");
  1120.     
  1121.     strcpy(undstr, unsstr);
  1122.     strcat(unsstr, "-");
  1123.     strcat(undstr, "~");
  1124.     strcat(undstr, dst); strcat(undstr,"))");
  1125.     strcat(unsstr, src); strcat(unsstr,"))");
  1126.     
  1127.     switch(type) {
  1128.      case flag_logical:
  1129.     printf("\tregs.v = regs.c = 0;\n");
  1130.     /* fall through */
  1131.      case flag_zn:
  1132.     switch(size) {
  1133.      case sz_byte:
  1134.         printf("\tregs.z = %s == 0;\n", vstr);
  1135.         printf("\tregs.n = %s < 0;\n", vstr);
  1136.         break;
  1137.      case sz_word:
  1138.         printf("\tregs.z = %s == 0;\n", vstr);
  1139.         printf("\tregs.n = %s < 0;\n", vstr);
  1140.         break;
  1141.      case sz_long:
  1142.         printf("\tregs.z = %s == 0;\n", vstr);
  1143.         printf("\tregs.n = %s < 0;\n", vstr);
  1144.         break;
  1145.      default:
  1146.         myabort();
  1147.     }
  1148.     break;
  1149.      case flag_add:
  1150.     start_brace();
  1151.     printf("\tbool flgs = %s < 0;\n", sstr);
  1152.     printf("\tbool flgo = %s < 0;\n", dstr);
  1153.     printf("\tbool flgn = %s < 0;\n", vstr);
  1154.     printf("\tregs.z = %s == 0;\n", vstr);
  1155.     printf("\tregs.v = (flgs == flgo) && (flgn != flgo);\n");
  1156.     printf("\tregs.c = regs.x = %s < %s;\n", undstr, usstr);
  1157.     printf("\tregs.n = flgn != 0;\n");
  1158.     break;
  1159.      case flag_sub:
  1160.     start_brace();
  1161.     printf("\tbool flgs = %s < 0;\n", sstr);
  1162.     printf("\tbool flgo = %s < 0;\n", dstr);
  1163.     printf("\tbool flgn = %s < 0;\n", vstr);
  1164.     printf("\tregs.z = %s == 0;\n", vstr);
  1165.     printf("\tregs.v = (flgs != flgo) && (flgn != flgo);\n");
  1166.     printf("\tregs.c = regs.x = %s > %s;\n", usstr, udstr);
  1167.     printf("\tregs.n = flgn != 0;\n");
  1168.     break;
  1169.      case flag_addx:
  1170.     start_brace();
  1171.     printf("\tbool flgs = %s < 0;\n", sstr);
  1172.     printf("\tbool flgo = %s < 0;\n", dstr);
  1173.     printf("\tbool flgn = %s < 0;\n", vstr);
  1174.     printf("\tif ((flgs && flgo && !flgn) || (!flgs && !flgo && flgn)) regs.v = 1;\n");
  1175.     printf("\tif ((flgs && flgo) || (!flgn && (flgo || flgs))) regs.c = regs.x = 1;\n");
  1176.     break;
  1177.      case flag_subx:
  1178.     start_brace();
  1179.     printf("\tbool flgs = %s < 0;\n", sstr);
  1180.     printf("\tbool flgo = %s < 0;\n", dstr);
  1181.     printf("\tbool flgn = %s < 0;\n", vstr);
  1182.     printf("\tif ((!flgs && flgo && !flgn) || (flgs && !flgo && flgn)) regs.v = 1;\n");
  1183.     printf("\tif ((flgs && !flgo) || (flgn && (!flgo || flgs))) regs.c = regs.x = 1;\n");
  1184.     break;
  1185.      case flag_cmp:
  1186.     start_brace();
  1187.     printf("\tbool flgs = %s < 0;\n", sstr);
  1188.     printf("\tbool flgo = %s < 0;\n", dstr);
  1189.     printf("\tbool flgn = %s < 0;\n", vstr);
  1190.     printf("\tregs.z = %s == 0;\n", vstr);
  1191.     printf("\tregs.v = (flgs != flgo) && (flgn != flgo);\n");
  1192.     printf("\tregs.c = %s > %s;\n", usstr, udstr);
  1193.     printf("\tregs.n = flgn != 0;\n");
  1194.     break;
  1195.     }
  1196. #else
  1197.     switch(type) {
  1198.      case flag_logical:
  1199.     printf("\tsetflags_logical(%s,%s);\n", value, mask);
  1200.     break;
  1201.      case flag_add:
  1202.     printf("\tsetflags_add(%s,%s,%s);\n", src, dest, value);
  1203.     break;
  1204.      case flag_sub:
  1205.     printf("\tsetflags_sub(%s,%s,%s);\n", src, dest, value);
  1206.     break;
  1207.      case flag_addx:
  1208.     printf("\tsetflags_addx(%s,%s,%s);\n", src, dest, value);
  1209.     break;
  1210.      case flag_subx:
  1211.     printf("\tsetflags_subx(%s,%s,%s);\n", src, dest, value);
  1212.     break;
  1213.      case flag_cmp:
  1214.     printf("\tsetflags_cmp(%s,%s,%s);\n", src, dest, value);
  1215.     break;
  1216.     }
  1217. #endif    
  1218. }
  1219.  
  1220. static void gen_opcode(unsigned long int opcode) 
  1221. {
  1222.     start_brace ();
  1223.     switch(table[opcode].mnemo) {
  1224.      case i_OR:
  1225.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "src", true, false);
  1226.     genamode(table[opcode].dmode, "dstreg", table[opcode].size, "dst", true, false);
  1227.     printf("\tsrc |= dst;\n");
  1228.     genflags(flag_logical, table[opcode].size, "src", "", "");
  1229.     genastore("src", table[opcode].dmode, "dstreg", table[opcode].size, "dst");
  1230.     break;
  1231.      case i_AND:
  1232.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "src", true, false);
  1233.     genamode(table[opcode].dmode, "dstreg", table[opcode].size, "dst", true, false);
  1234.     printf("\tsrc &= dst;\n");
  1235.     genflags(flag_logical, table[opcode].size, "src", "", "");
  1236.     genastore("src", table[opcode].dmode, "dstreg", table[opcode].size, "dst");
  1237.     break;
  1238.      case i_EOR:
  1239.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "src", true, false);
  1240.     genamode(table[opcode].dmode, "dstreg", table[opcode].size, "dst", true, false);
  1241.     printf("\tsrc ^= dst;\n");
  1242.     genflags(flag_logical, table[opcode].size, "src", "", "");
  1243.     genastore("src", table[opcode].dmode, "dstreg", table[opcode].size, "dst");
  1244.     break;
  1245.      case i_ORSR:
  1246.     if (table[opcode].size != sz_byte) {
  1247.         printf("\tif (!regs.s) { regs.pc_p--; Exception(8); } else\n");
  1248.     }
  1249.     start_brace ();
  1250.     printf("\tMakeSR();\n");
  1251.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "src", true, false);
  1252.     if (table[opcode].size == sz_byte) {
  1253.         printf("\tsrc &= 0xFF;\n");
  1254.     }
  1255.     printf("\tregs.sr |= src;\n");
  1256.     printf("\tMakeFromSR();\n");
  1257.     break;
  1258.      case i_ANDSR: 
  1259.     if (table[opcode].size != sz_byte) {
  1260.         printf("\tif (!regs.s) { regs.pc_p--; Exception(8); } else\n");
  1261.     }
  1262.     start_brace();
  1263.     
  1264.     printf("\tMakeSR();\n");
  1265.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "src", true, false);
  1266.     if (table[opcode].size == sz_byte) {
  1267.         printf("\tsrc |= 0xFF00;\n");
  1268.     }
  1269.     printf("\tregs.sr &= src;\n");
  1270.     printf("\tMakeFromSR();\n");
  1271.     break;
  1272.      case i_EORSR:
  1273.     if (table[opcode].size != sz_byte) {
  1274.         printf("\tif (!regs.s) { regs.pc_p--; Exception(8); } else\n");
  1275.     }
  1276.     start_brace ();
  1277.     printf("\tMakeSR();\n");
  1278.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "src", true, false);
  1279.     if (table[opcode].size == sz_byte) {
  1280.         printf("\tsrc &= 0xFF;\n");
  1281.     }
  1282.     printf("\tregs.sr ^= src;\n");
  1283.     printf("\tMakeFromSR();\n");
  1284.     break;
  1285.      case i_SUB: 
  1286.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "src", true, false);
  1287.     genamode(table[opcode].dmode, "dstreg", table[opcode].size, "dst", true, false);
  1288.     start_brace ();
  1289.     printf("\tULONG newv = dst - src;\n");
  1290.     genflags(flag_sub, table[opcode].size, "newv", "src", "dst");
  1291.     genastore("newv", table[opcode].dmode, "dstreg", table[opcode].size, "dst");
  1292.     break;
  1293.      case i_SUBA:
  1294.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "src", true, false);
  1295.     genamode(table[opcode].dmode, "dstreg", sz_long, "dst", true, false);
  1296.     start_brace ();
  1297.     printf("\tULONG newv = dst - src;\n");
  1298.     genastore("newv", table[opcode].dmode, "dstreg", sz_long, "dst");
  1299.     break;
  1300.      case i_SUBX:
  1301.     {
  1302.         int old_brace_level;
  1303.         genamode(table[opcode].smode, "srcreg", table[opcode].size, "src", true, false);
  1304.         genamode(table[opcode].dmode, "dstreg", table[opcode].size, "dst", true, false);
  1305.         start_brace ();
  1306.         printf("\tbool xflg = regs.x;\n");
  1307.         printf("\tregs.v = regs.c = regs.x = 0;\n");
  1308.         start_brace ();
  1309.         printf("\tULONG newv = dst - src;\n");
  1310.         genflags(flag_subx, table[opcode].size, "newv", "src", "dst");
  1311.         /* FIXME: I'm not entirely sure how to handle this */
  1312.         printf("\tif (xflg)\n"); 
  1313.         old_brace_level = n_braces;
  1314.         start_brace ();
  1315.         genflags(flag_subx, table[opcode].size, "(newv-1)", "1", "newv");
  1316.         printf("\tnewv--;\n");
  1317.         pop_braces(old_brace_level);
  1318.         
  1319.         genflags(flag_zn, table[opcode].size, "newv", "", "");
  1320.         genastore("newv", table[opcode].dmode, "dstreg", table[opcode].size, "dst");
  1321.     }
  1322.     break;
  1323.      case i_SBCD:
  1324.     /* Let's hope this works... */
  1325.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "src", true, false);
  1326.     genamode(table[opcode].dmode, "dstreg", table[opcode].size, "dst", true, false);
  1327.     start_brace ();
  1328.     printf("\tUWORD newv = dst - src - regs.x;\n");
  1329.     printf("\tif ((newv & 0xF) > 9) newv-=6;\n");
  1330.     printf("\tregs.c = regs.x = (newv & 0x1F0) > 0x90;\n");
  1331.     printf("\tif (regs.c) newv -= 0x60;\n");
  1332.     printf("\tif (newv != 0) regs.z = 0;\n");
  1333.     genastore("newv", table[opcode].dmode, "dstreg", table[opcode].size, "dst");
  1334.     break;
  1335.      case i_ADD:
  1336.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "src", true, false);
  1337.     genamode(table[opcode].dmode, "dstreg", table[opcode].size, "dst", true, false);
  1338.     start_brace ();
  1339.     printf("\tULONG newv = dst + src;\n");
  1340.     genflags(flag_add, table[opcode].size, "newv", "src", "dst");
  1341.     genastore("newv", table[opcode].dmode, "dstreg", table[opcode].size, "dst");
  1342.     break;
  1343.      case i_ADDA: 
  1344.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "src", true, false);
  1345.     genamode(table[opcode].dmode, "dstreg", sz_long, "dst", true, false);
  1346.     start_brace ();
  1347.     printf("\tULONG newv = dst + src;\n");
  1348.     genastore("newv", table[opcode].dmode, "dstreg", sz_long, "dst");
  1349.     break;
  1350.      case i_ADDX:
  1351.     {
  1352.         int old_brace_level;
  1353.         genamode(table[opcode].smode, "srcreg", table[opcode].size, "src", true, false);
  1354.         genamode(table[opcode].dmode, "dstreg", table[opcode].size, "dst", true, false);
  1355.         start_brace ();
  1356.         printf("\tbool xflg = regs.x;\n");
  1357.         printf("\tregs.v = regs.c = regs.x = 0;\n");
  1358.         start_brace ();
  1359.         printf("\tULONG newv = dst + src;\n");
  1360.         genflags(flag_addx, table[opcode].size, "newv", "src", "dst");
  1361.         printf("\tif (xflg)\n");
  1362.         old_brace_level = n_braces;
  1363.         start_brace ();
  1364.         genflags(flag_addx, table[opcode].size, "(newv+1)", "newv", "1");
  1365.         printf("\tnewv++;\n");
  1366.         pop_braces(old_brace_level);
  1367.         genflags(flag_zn, table[opcode].size, "newv", "", "");
  1368.         genastore("newv", table[opcode].dmode, "dstreg", table[opcode].size, "dst");
  1369.     }
  1370.     break;
  1371.      case i_ABCD:
  1372.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "src", true, false);
  1373.     genamode(table[opcode].dmode, "dstreg", table[opcode].size, "dst", true, false);
  1374.     start_brace ();
  1375.     printf("\tUWORD newv = src + dst + regs.x;\n");
  1376.     printf("\tif ((newv & 0xF) > 9) newv+=6;\n");
  1377.     printf("\tregs.c = regs.x = (newv & 0x1F0) > 0x90;\n");
  1378.     printf("\tif (regs.c) newv += 0x60;\n");
  1379.     printf("\tif (newv != 0) regs.z = 0;\n");
  1380.     genastore("newv", table[opcode].dmode, "dstreg", table[opcode].size, "dst");
  1381.     break;
  1382.      case i_NEG:
  1383.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "src", true, false);
  1384.     start_brace ();
  1385.     printf("\tULONG dst = -src;\n");
  1386.     genflags(flag_sub, table[opcode].size, "dst", "src", "0");
  1387.     genastore("dst",table[opcode].smode, "srcreg", table[opcode].size, "src");
  1388.     break;
  1389.      case i_NEGX:
  1390.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "src", true, false);
  1391.     start_brace ();
  1392.     printf("\tULONG dst = -src-regs.x;\n");
  1393.     genflags(flag_sub, table[opcode].size, "dst", "src", "0");
  1394.     genastore("dst",table[opcode].smode, "srcreg", table[opcode].size, "src");
  1395.     break;
  1396.      case i_NBCD: 
  1397.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "src", true, false);
  1398.     start_brace ();
  1399.     printf("\tUWORD newv = - src - regs.x;\n");
  1400.     printf("\tif ((newv & 0xF) > 9) newv-=6;\n");
  1401.     printf("\tregs.c = regs.x = (newv & 0x1F0) > 0x90;\n");
  1402.     printf("\tif (regs.c) newv -= 0x60;\n");
  1403.     printf("\tif (newv != 0) regs.z = 0;\n");
  1404.     genastore("newv", table[opcode].smode, "srcreg", table[opcode].size, "src");
  1405.     break;
  1406.      case i_CLR: 
  1407.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "src", false, false);
  1408.     genflags(flag_logical, table[opcode].size, "0", "", "");
  1409.     genastore("0",table[opcode].smode, "srcreg", table[opcode].size, "src");
  1410.     break;
  1411.      case i_NOT: 
  1412.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "src", true, false);
  1413.     start_brace ();
  1414.     printf("\tULONG dst = ~src;\n");
  1415.     genflags(flag_logical, table[opcode].size, "dst", "", "");
  1416.     genastore("dst",table[opcode].smode, "srcreg", table[opcode].size, "src");
  1417.     break;
  1418.      case i_TST:
  1419.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "src", true, false);
  1420.     genflags(flag_logical, table[opcode].size, "src", "", "");
  1421.     break;
  1422.      case i_BTST:
  1423.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "src", true, false);
  1424.     genamode(table[opcode].dmode, "dstreg", table[opcode].size, "dst", true, false);
  1425.     if (table[opcode].size == sz_byte)
  1426.         printf("\tsrc &= 7;\n");
  1427.     else
  1428.         printf("\tsrc &= 31;\n");
  1429.     printf("\tregs.z = !(dst & (1 << src));\n");
  1430.     break;
  1431.      case i_BCHG:
  1432.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "src", true, false);
  1433.     genamode(table[opcode].dmode, "dstreg", table[opcode].size, "dst", true, false);
  1434.     if (table[opcode].size == sz_byte)
  1435.         printf("\tsrc &= 7;\n");
  1436.     else
  1437.         printf("\tsrc &= 31;\n");
  1438.     printf("\tregs.z = !(dst & (1 << src));\n");
  1439.     printf("\tdst ^= (1 << src);\n");
  1440.     genastore("dst", table[opcode].dmode, "dstreg", table[opcode].size, "dst");
  1441.     break;
  1442.      case i_BCLR:
  1443.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "src", true, false);
  1444.     genamode(table[opcode].dmode, "dstreg", table[opcode].size, "dst", true, false);
  1445.     if (table[opcode].size == sz_byte)
  1446.         printf("\tsrc &= 7;\n");
  1447.     else
  1448.         printf("\tsrc &= 31;\n");
  1449.     printf("\tregs.z = !(dst & (1 << src));\n");
  1450.     printf("\tdst &= ~(1 << src);\n");
  1451.     genastore("dst", table[opcode].dmode, "dstreg", table[opcode].size, "dst");
  1452.     break;
  1453.      case i_BSET:
  1454.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "src", true, false);
  1455.     genamode(table[opcode].dmode, "dstreg", table[opcode].size, "dst", true, false);
  1456.     if (table[opcode].size == sz_byte)
  1457.         printf("\tsrc &= 7;\n");
  1458.     else
  1459.         printf("\tsrc &= 31;\n");
  1460.     printf("\tregs.z = !(dst & (1 << src));\n");
  1461.     printf("\tdst |= (1 << src);\n");
  1462.     genastore("dst", table[opcode].dmode, "dstreg", table[opcode].size, "dst");
  1463.     break;
  1464.      case i_CMPM:
  1465.      case i_CMP:
  1466.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "src", true, false);
  1467.     genamode(table[opcode].dmode, "dstreg", table[opcode].size, "dst", true, false);
  1468.     start_brace ();
  1469.     printf("\tULONG newv = dst - src;\n");
  1470.     genflags(flag_cmp, table[opcode].size, "newv", "src", "dst");
  1471.     break;
  1472.      case i_CMPA: 
  1473.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "src", true, false);
  1474.     genamode(table[opcode].dmode, "dstreg", sz_long, "dst", true, false);
  1475.     start_brace ();
  1476.     printf("\tULONG newv = dst - src;\n");
  1477.     genflags(flag_cmp, sz_long, "newv", "src", "dst");
  1478.     break;
  1479.      case i_MOVEP: 
  1480.     printf("\tfprintf(stderr, \"MOVEP\\n\");\n");
  1481.     break;
  1482.      case i_MOVE:
  1483.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "src", true, false);
  1484.     genamode(table[opcode].dmode, "dstreg", table[opcode].size, "dst", false, false);
  1485.     genflags(flag_logical, table[opcode].size, "src", "", "");
  1486.     genastore("src", table[opcode].dmode, "dstreg", table[opcode].size, "dst");
  1487.     break;
  1488.      case i_MOVEA:
  1489.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "src", true, false);
  1490.     genamode(table[opcode].dmode, "dstreg", table[opcode].size, "dst", false, false);
  1491.     genastore("src", table[opcode].dmode, "dstreg", table[opcode].size, "dst");
  1492.     break;
  1493.      case i_MVSR2: 
  1494.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "src", false, false);
  1495.     printf("\tMakeSR();\n");
  1496.     genastore("regs.sr", table[opcode].smode, "srcreg", table[opcode].size, "src");
  1497.     break;
  1498.      case i_MV2SR:
  1499.     if (table[opcode].size != sz_byte) {
  1500.         printf("\tif (!regs.s) { regs.pc_p--; Exception(8); } else\n");
  1501.     }
  1502.     start_brace ();
  1503.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "src", true, false);
  1504.     if (table[opcode].size == sz_byte)
  1505.         printf("\tMakeSR();\n\tregs.sr &= 0xFF00;\n\tregs.sr |= src & 0xFF;\n");
  1506.     else {            
  1507.         printf("\tregs.sr = src;\n");
  1508.     }
  1509.     printf("\tMakeFromSR();\n");
  1510.     break;
  1511.      case i_SWAP: 
  1512.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "src", true, false);
  1513.     start_brace ();
  1514.     printf("\tULONG dst = ((src >> 16)&0xFFFF) | ((src&0xFFFF)<<16);\n");
  1515.     genflags(flag_logical, table[opcode].size, "dst", "", "");
  1516.     genastore("dst",table[opcode].smode, "srcreg", table[opcode].size, "src");
  1517.     break;
  1518.      case i_EXG:
  1519.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "src", true, false);
  1520.     genamode(table[opcode].dmode, "dstreg", table[opcode].size, "dst", true, false);
  1521.     genastore("dst",table[opcode].smode, "srcreg", table[opcode].size, "src");
  1522.     genastore("src",table[opcode].dmode, "dstreg", table[opcode].size, "dst");
  1523.     break;
  1524.      case i_EXT:
  1525.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "src", true, false);
  1526.     start_brace ();
  1527.     switch(table[opcode].size) {
  1528.      case sz_word: printf("\tULONG dst = (LONG)(BYTE)src;\n"); break;
  1529.      case sz_long: printf("\tULONG dst = (LONG)(WORD)src;\n"); break;
  1530.      default: myabort();
  1531.     }
  1532.     genflags(flag_logical, table[opcode].size, "dst", "", "");
  1533.     genastore("dst",table[opcode].smode, "srcreg", table[opcode].size, "src");
  1534.     break;
  1535.      case i_MVMEL:
  1536.     genmovemel(opcode);
  1537.     break;
  1538.      case i_MVMLE:
  1539.     genmovemle(opcode);
  1540.     break;
  1541.      case i_TRAP:
  1542.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "src", true, false);
  1543.     printf("\tException(src+32);\n");
  1544.     break;
  1545.      case i_MVR2USP:
  1546.     printf("\tif (!regs.s) { regs.pc_p--; Exception(8); } else {\n");
  1547.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "src", true, false);
  1548.     printf("\tregs.usp = src;\n");
  1549.     printf("\t}\n");
  1550.     break;
  1551.      case i_MVUSP2R: 
  1552.     printf("\tif (!regs.s) { regs.pc_p--; Exception(8); } else {\n");
  1553.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "src", false, false);
  1554.     genastore("regs.usp", table[opcode].smode, "srcreg", table[opcode].size, "src");
  1555.     printf("\t}\n");
  1556.     break;
  1557.      case i_RESET:
  1558.     printf("\tcustomreset();\n");
  1559.     break;
  1560.      case i_NOP:
  1561.     break;
  1562.      case i_STOP:
  1563.     printf("\tif (!regs.s) { regs.pc_p--; Exception(8); } else {\n");
  1564.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "src", true, false);
  1565.     printf("\tregs.sr = src;\n");
  1566.     printf("\tMakeFromSR();\n");
  1567.     printf("\tm68k_setstopped(1);\n");
  1568.     printf("\t}\n");
  1569.     break;
  1570.      case i_RTE:
  1571.     genamode(Aipi, "7", sz_word, "sr", true, false);
  1572.     genamode(Aipi, "7", sz_long, "pc", true, false);
  1573.     printf("\tregs.sr = sr; m68k_setpc(pc);\n");
  1574.     printf("\tMakeFromSR();\n");
  1575.     break;
  1576.      case i_RTD:
  1577.     break;
  1578.      case i_LINK:
  1579.     genamode(Apdi, "7", sz_long, "old", false, false);
  1580.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "src", true, false);
  1581.     genastore("src", Apdi, "7", sz_long, "old");
  1582.     genastore("regs.a[7]", table[opcode].smode, "srcreg", table[opcode].size, "src");
  1583.     genamode(table[opcode].dmode, "dstreg", table[opcode].size, "offs", true, false);
  1584.     printf("\tregs.a[7] += offs;\n");
  1585.     break;
  1586.      case i_UNLK:
  1587.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "src", true, false);
  1588.     printf("\tregs.a[7] = src;\n");
  1589.     genamode(Aipi, "7", sz_long, "old", true, false);
  1590.     genastore("old", table[opcode].smode, "srcreg", table[opcode].size, "src");
  1591.     break;
  1592.      case i_RTS:
  1593.     genamode(Aipi, "7", sz_long, "pc", true, false);
  1594.     printf("\tm68k_setpc(pc);\n");
  1595.     break;
  1596.      case i_TRAPV:
  1597.     printf("\tif(regs.v) Exception(7);\n");
  1598.     break;
  1599.      case i_RTR: 
  1600.     printf("\tMakeSR();\n");
  1601.     genamode(Aipi, "7", sz_word, "sr", true, false);
  1602.     genamode(Aipi, "7", sz_long, "pc", true, false);
  1603.     printf("\tregs.sr &= 0xFF00; sr &= 0xFF;\n");
  1604.     printf("\tregs.sr |= sr; m68k_setpc(pc);\n");
  1605.     printf("\tMakeFromSR();\n");
  1606.     break;
  1607.      case i_JSR:
  1608.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "src", false, false);
  1609.     genamode(Apdi, "7", sz_long, "sp", false, false);
  1610.     genastore("m68k_getpc()", Apdi, "7", sz_long, "sp");
  1611.     printf("\tm68k_setpc(srca);\n");
  1612.     break;
  1613.      case i_JMP: 
  1614.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "src", false, false);
  1615.     printf("\tm68k_setpc(srca);\n");
  1616.     break;
  1617.      case i_BSR:
  1618.     printf("\tchar *oldpcp = (char *)regs.pc_p;\n");
  1619.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "src", true, false);
  1620.     genamode(Apdi, "7", sz_long, "sp", false, false);
  1621.     genastore("m68k_getpc()", Apdi, "7", sz_long, "sp");
  1622.     printf("\tregs.pc_p = (UWORD *)(oldpcp + (LONG)src);\n");
  1623.     break;
  1624.      case i_Bcc:
  1625.     printf("\tchar *oldpcp = (char *)regs.pc_p;\n");
  1626.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "src", true, false);
  1627.     printf("\tif (cctrue(%d)) regs.pc_p = (UWORD *)(oldpcp + (LONG)src);\n", table[opcode].cc);
  1628.     break;
  1629.      case i_LEA:
  1630.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "src", false, false);
  1631.     genamode(table[opcode].dmode, "dstreg", table[opcode].size, "dst", false, false);
  1632.     genastore("srca", table[opcode].dmode, "dstreg", table[opcode].size, "dst");
  1633.     break;
  1634.      case i_PEA:
  1635.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "src", false, false);
  1636.     genamode(Apdi, "7", sz_long, "dst", false, false);
  1637.     genastore("srca", Apdi, "7", sz_long, "dst");
  1638.     break;
  1639.      case i_DBcc:
  1640.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "src", true, false);
  1641.     genamode(table[opcode].dmode, "dstreg", table[opcode].size, "offs", true, false);
  1642.     printf("\tif (!cctrue(%d)) {\n", table[opcode].cc);
  1643.     printf("\tif (src--) regs.pc_p = (UWORD *)((char *)regs.pc_p + (LONG)offs - 2);\n");
  1644.     genastore("src", table[opcode].smode, "srcreg", table[opcode].size, "src");
  1645.     printf("\t}\n");
  1646.     break;
  1647.      case i_Scc: 
  1648.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "src", false, false);
  1649.     start_brace ();
  1650.     printf("\tint val = cctrue(%d) ? 0xff : 0;\n", table[opcode].cc);
  1651.     genastore("val",table[opcode].smode, "srcreg", table[opcode].size, "src");
  1652.     break;
  1653.      case i_DIVU:
  1654.     genamode(table[opcode].smode, "srcreg", sz_word, "src", true, false);
  1655.     genamode(table[opcode].dmode, "dstreg", sz_long, "dst", true, false);
  1656.     printf("\tif(src != 0){\n");
  1657.     printf("\tULONG newv = (ULONG)dst / (UWORD)src;\n");
  1658.     printf("\tULONG rem = (ULONG)dst %% (UWORD)src;\n");
  1659.     /* The N flag appears to be set each time there is an overflow.
  1660.      * Weird. */
  1661.     printf("\tif (newv > 0xffff) { regs.v = regs.n = 1; } else\n\t{\n");
  1662.     genflags(flag_logical, sz_word, "newv", "", "");
  1663.     printf("\tnewv = (newv & 0xffff) | ((ULONG)rem << 16);\n");
  1664.     genastore("newv",table[opcode].dmode, "dstreg", sz_long, "dst");
  1665.     printf("\t}\n");
  1666.     printf("\t}\n");
  1667.     break;
  1668.      case i_DIVS: 
  1669.     genamode(table[opcode].smode, "srcreg", sz_word, "src", true, false);
  1670.     genamode(table[opcode].dmode, "dstreg", sz_long, "dst", true, false);
  1671.     printf("\tif(src != 0){\n");
  1672.     printf("\tLONG newv = (LONG)dst / (WORD)src;\n");
  1673.     printf("\tUWORD rem = (LONG)dst %% (WORD)src;\n");
  1674.     printf("\tif ((newv & 0xffff0000) && (newv & 0xffff0000) != 0xffff0000) { regs.v = regs.n = 1; } else\n\t{\n");
  1675.     printf("\tif (((WORD)rem < 0) != ((LONG)dst < 0)) rem = -rem;\n");
  1676.     genflags(flag_logical, sz_word, "newv", "", "");
  1677.     printf("\tnewv = (newv & 0xffff) | ((ULONG)rem << 16);\n");
  1678.     genastore("newv",table[opcode].dmode, "dstreg", sz_long, "dst");
  1679.     printf("\t}\n");
  1680.     printf("\t}\n");
  1681.     break;
  1682.      case i_MULU: 
  1683.     genamode(table[opcode].smode, "srcreg", sz_word, "src", true, false);
  1684.     genamode(table[opcode].dmode, "dstreg", sz_word, "dst", true, false);
  1685.     start_brace ();
  1686.     printf("\tULONG newv = (ULONG)(UWORD)dst * (ULONG)(UWORD)src;\n");
  1687.     genflags(flag_logical, sz_long, "newv", "", "");
  1688.     genastore("newv",table[opcode].dmode, "dstreg", sz_long, "dst");
  1689. #ifdef WANT_SLOW_MULTIPLY
  1690.     printf("\tspecialflags |= SPCFLAG_EXTRA_CYCLES;\n");
  1691. #endif
  1692.     break;
  1693.      case i_MULS:
  1694.     genamode(table[opcode].smode, "srcreg", sz_word, "src", true, false);
  1695.     genamode(table[opcode].dmode, "dstreg", sz_word, "dst", true, false);
  1696.     start_brace ();
  1697.     printf("\tULONG newv = (LONG)(WORD)dst * (LONG)(WORD)src;\n");
  1698.     genflags(flag_logical, sz_long, "newv", "", "");
  1699.     genastore("newv",table[opcode].dmode, "dstreg", sz_long, "dst");
  1700. #ifdef WANT_SLOW_MULTIPLY
  1701.     printf("\tspecialflags |= SPCFLAG_EXTRA_CYCLES;\n");
  1702. #endif
  1703.     break;
  1704.      case i_ASR: 
  1705.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "cnt", true, false);
  1706.     genamode(table[opcode].dmode, "dstreg", table[opcode].size, "data", true, false);
  1707.     start_brace ();
  1708.     switch(table[opcode].size) {
  1709.      case sz_byte: printf("\tUBYTE val = data;\n"); break;
  1710.      case sz_word: printf("\tUWORD val = data;\n"); break;
  1711.      case sz_long: printf("\tULONG val = data;\n"); break;
  1712.      default: myabort();
  1713.     }
  1714.     printf("\tcnt &= 63;\n");
  1715.     printf("\tregs.v = 0;\n");
  1716.     start_brace ();
  1717.     switch(table[opcode].size) {
  1718.      case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
  1719.      case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
  1720.      case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
  1721.      default: myabort();
  1722.     }
  1723.     printf("\tULONG sign = cmask & val;\n");
  1724.     printf("\tfor(;cnt;--cnt){\n");
  1725.     printf("\tregs.c=regs.x=val&1; val = ((ULONG)val >> 1) | sign;\n");
  1726.     printf("\t}\n\tregs.n = sign != 0;\n");
  1727.     printf("\tregs.z = val == 0;\n");
  1728.     genastore("val", table[opcode].dmode, "dstreg", table[opcode].size, "data");
  1729.     break;
  1730.      case i_ASL:
  1731.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "cnt", true, false);
  1732.     genamode(table[opcode].dmode, "dstreg", table[opcode].size, "data", true, false);
  1733.     start_brace ();
  1734.     switch(table[opcode].size) {
  1735.      case sz_byte: printf("\tUBYTE val = data;\n"); break;
  1736.      case sz_word: printf("\tUWORD val = data;\n"); break;
  1737.      case sz_long: printf("\tULONG val = data;\n"); break;
  1738.      default: myabort();
  1739.     }
  1740.     printf("\tcnt &= 63;\n");
  1741.     printf("\tregs.v = 0;\n");
  1742.     start_brace ();
  1743.     switch(table[opcode].size) {
  1744.      case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
  1745.      case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
  1746.      case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
  1747.      default: myabort();
  1748.     }
  1749.     printf("\tULONG sign = cmask & val;\n");
  1750.     printf("\tfor(;cnt;--cnt){\n");
  1751.     printf("\tregs.c=regs.x=(val&cmask)!=0; val <<= 1;\n");
  1752.     printf("\tif ((val&cmask)!=sign)regs.v=1;\n");
  1753.     printf("\t}\n\tregs.n = (val&cmask) != 0;\n");
  1754.     printf("\tregs.z = val == 0;\n");
  1755.     genastore("val", table[opcode].dmode, "dstreg", table[opcode].size, "data");
  1756.     break;
  1757.      case i_LSR:
  1758.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "cnt", true, false);
  1759.     genamode(table[opcode].dmode, "dstreg", table[opcode].size, "data", true, false);
  1760.     start_brace ();
  1761.     switch(table[opcode].size) {
  1762.      case sz_byte: printf("\tUBYTE val = data;\n"); break;
  1763.      case sz_word: printf("\tUWORD val = data;\n"); break;
  1764.      case sz_long: printf("\tULONG val = data;\n"); break;
  1765.      default: myabort();
  1766.     }
  1767.     printf("\tcnt &= 63;\n");
  1768.     start_brace ();
  1769.     printf("\tint carry = 0;\n");
  1770.     printf("\tfor(;cnt;--cnt){\n");
  1771.     printf("\tcarry=val&1; val >>= 1;\n");
  1772.     printf("\t}\n");
  1773.     genflags(flag_logical, table[opcode].size, "val", "", "");
  1774.     printf("regs.c = regs.x = carry!=0;\n");
  1775.     genastore("val", table[opcode].dmode, "dstreg", table[opcode].size, "data");
  1776.     break;
  1777.      case i_LSL:
  1778.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "cnt", true, false);
  1779.     genamode(table[opcode].dmode, "dstreg", table[opcode].size, "data", true, false);
  1780.     start_brace ();
  1781.     switch(table[opcode].size) {
  1782.      case sz_byte: printf("\tUBYTE val = data;\n"); break;
  1783.      case sz_word: printf("\tUWORD val = data;\n"); break;
  1784.      case sz_long: printf("\tULONG val = data;\n"); break;
  1785.      default: myabort();
  1786.     }
  1787.     printf("\tcnt &= 63;\n");
  1788.     start_brace ();
  1789.     printf("\tint carry = 0;\n");
  1790.     switch(table[opcode].size) {
  1791.      case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
  1792.      case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
  1793.      case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
  1794.      default: myabort();
  1795.     }
  1796.     printf("\tfor(;cnt;--cnt){\n");
  1797.     printf("\tcarry=val&cmask; val <<= 1;\n");
  1798.     printf("\t}\n");
  1799.     genflags(flag_logical, table[opcode].size, "val", "", "");
  1800.     printf("regs.c = regs.x = carry!=0;\n");
  1801.     genastore("val", table[opcode].dmode, "dstreg", table[opcode].size, "data");
  1802.     break;
  1803.      case i_ROL:
  1804.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "cnt", true, false);
  1805.     genamode(table[opcode].dmode, "dstreg", table[opcode].size, "data", true, false);
  1806.     start_brace ();
  1807.     switch(table[opcode].size) {
  1808.      case sz_byte: printf("\tUBYTE val = data;\n"); break;
  1809.      case sz_word: printf("\tUWORD val = data;\n"); break;
  1810.      case sz_long: printf("\tULONG val = data;\n"); break;
  1811.      default: myabort();
  1812.     }
  1813.     printf("\tcnt &= 63;\n");
  1814.     start_brace ();
  1815.     printf("\tint carry = 0;\n");
  1816.     switch(table[opcode].size) {
  1817.      case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
  1818.      case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
  1819.      case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
  1820.      default: myabort();
  1821.     }
  1822.     printf("\tfor(;cnt;--cnt){\n");
  1823.     printf("\tcarry=val&cmask; val <<= 1;\n");
  1824.     printf("\tif(carry)  val |= 1;\n");
  1825.     printf("\t}\n");
  1826.     genflags(flag_logical, table[opcode].size, "val", "", "");
  1827.     printf("regs.c = carry!=0;\n");
  1828.     genastore("val", table[opcode].dmode, "dstreg", table[opcode].size, "data");
  1829.     break;
  1830.      case i_ROR:
  1831.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "cnt", true, false);
  1832.     genamode(table[opcode].dmode, "dstreg", table[opcode].size, "data", true, false);
  1833.     start_brace ();
  1834.     switch(table[opcode].size) {
  1835.      case sz_byte: printf("\tUBYTE val = data;\n"); break;
  1836.      case sz_word: printf("\tUWORD val = data;\n"); break;
  1837.      case sz_long: printf("\tULONG val = data;\n"); break;
  1838.      default: myabort();
  1839.     }
  1840.     
  1841.     printf("\tcnt &= 63;\n");
  1842.     start_brace ();
  1843.     printf("\tint carry = 0;\n");
  1844.     switch(table[opcode].size) {
  1845.      case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
  1846.      case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
  1847.      case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
  1848.      default: myabort();
  1849.     }
  1850.     printf("\tfor(;cnt;--cnt){\n");
  1851.     printf("\tcarry=val&1; val = (ULONG)val >> 1;\n");
  1852.     printf("\tif(carry) val |= cmask;\n");
  1853.     printf("\t}\n");
  1854.     genflags(flag_logical, table[opcode].size, "val", "", "");
  1855.     printf("\tregs.c = carry!=0;\n");
  1856.     genastore("val", table[opcode].dmode, "dstreg", table[opcode].size, "data");
  1857.     break;
  1858.      case i_ROXL: 
  1859.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "cnt", true, false);
  1860.     genamode(table[opcode].dmode, "dstreg", table[opcode].size, "data", true, false);
  1861.     start_brace ();
  1862.     switch(table[opcode].size) {
  1863.      case sz_byte: printf("\tUBYTE val = data;\n"); break;
  1864.      case sz_word: printf("\tUWORD val = data;\n"); break;
  1865.      case sz_long: printf("\tULONG val = data;\n"); break;
  1866.      default: myabort();
  1867.     }
  1868.     printf("\tcnt &= 63;\n");
  1869.     start_brace ();
  1870.     printf("\tint carry = 0;\n");
  1871.     switch(table[opcode].size) {
  1872.      case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
  1873.      case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
  1874.      case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
  1875.      default: myabort();
  1876.     }
  1877.     printf("\tfor(;cnt;--cnt){\n");
  1878.     printf("\tcarry=val&cmask; val <<= 1;\n");
  1879.     printf("\tif(regs.x) val |= 1;\n");    
  1880.     printf("\tregs.x = carry != 0;\n");
  1881.     printf("\t}\n");
  1882.     genflags(flag_logical, table[opcode].size, "val", "", "");
  1883.     printf("\tregs.x = regs.c = carry!=0;\n");
  1884.     genastore("val", table[opcode].dmode, "dstreg", table[opcode].size, "data");
  1885.     break;
  1886.      case i_ROXR:
  1887.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "cnt", true, false);
  1888.     genamode(table[opcode].dmode, "dstreg", table[opcode].size, "data", true, false);
  1889.     start_brace ();
  1890.     switch(table[opcode].size) {
  1891.      case sz_byte: printf("\tUBYTE val = data;\n"); break;
  1892.      case sz_word: printf("\tUWORD val = data;\n"); break;
  1893.      case sz_long: printf("\tULONG val = data;\n"); break;
  1894.      default: myabort();
  1895.     }
  1896.     printf("\tcnt &= 63;\n");
  1897.     start_brace ();
  1898.     printf("\tint carry = 0;\n");
  1899.     switch(table[opcode].size) {
  1900.      case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
  1901.      case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
  1902.      case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
  1903.      default: myabort();
  1904.     }
  1905.     printf("\tfor(;cnt;--cnt){\n");
  1906.     printf("\tcarry=val&1; val >>= 1;\n");
  1907.     printf("\tif(regs.x) val |= cmask;\n");
  1908.     printf("\tregs.x = carry != 0;\n");
  1909.     printf("\t}\n");
  1910.     genflags(flag_logical, table[opcode].size, "val", "", "");
  1911.     printf("\tregs.x = regs.c = carry!=0;\n");
  1912.     genastore("val", table[opcode].dmode, "dstreg", table[opcode].size, "data");
  1913.     break;
  1914.      case i_ASRW:
  1915.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "data", true, false);
  1916.     printf("\tregs.v = 0;\n");
  1917.     start_brace ();
  1918.     switch(table[opcode].size) {
  1919.      case sz_byte: printf("\tUBYTE val = data;\n"); break;
  1920.      case sz_word: printf("\tUWORD val = data;\n"); break;
  1921.      case sz_long: printf("\tULONG val = data;\n"); break;
  1922.      default: myabort();
  1923.     }
  1924.     switch(table[opcode].size) {
  1925.      case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
  1926.      case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
  1927.      case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
  1928.      default: myabort();
  1929.     }
  1930.     printf("\tULONG sign = cmask & val;\n");
  1931.     printf("\tregs.c=regs.x=val&1; val = (val >> 1) | sign;\n");
  1932.     printf("\tregs.n = sign != 0;\n");
  1933.     printf("\tregs.z = val == 0;\n");
  1934.     genastore("val", table[opcode].smode, "srcreg", table[opcode].size, "data");
  1935.     break;
  1936.      case i_ASLW:
  1937.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "data", true, false);
  1938.     printf("\tregs.v = 0;\n");
  1939.     start_brace ();
  1940.     switch(table[opcode].size) {
  1941.      case sz_byte: printf("\tUBYTE val = data;\n"); break;
  1942.      case sz_word: printf("\tUWORD val = data;\n"); break;
  1943.      case sz_long: printf("\tULONG val = data;\n"); break;
  1944.      default: myabort();
  1945.     }
  1946.     switch(table[opcode].size) {
  1947.      case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
  1948.      case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
  1949.      case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
  1950.      default: myabort();
  1951.     }
  1952.     printf("\tULONG sign = cmask & val;\n");
  1953.     printf("\tregs.c=regs.x=(val&cmask)!=0; val <<= 1;\n");
  1954.     printf("\tif ((val&cmask)!=sign)regs.v=1;\n");
  1955.     printf("\tregs.n = (val&cmask) != 0;\n");
  1956.     printf("\tregs.z = val == 0;\n");
  1957.     genastore("val", table[opcode].smode, "srcreg", table[opcode].size, "data");
  1958.     break;
  1959.      case i_LSRW:
  1960.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "data", true, false);
  1961.     start_brace ();
  1962.     switch(table[opcode].size) {
  1963.      case sz_byte: printf("\tUBYTE val = data;\n"); break;
  1964.      case sz_word: printf("\tUWORD val = data;\n"); break;
  1965.      case sz_long: printf("\tULONG val = data;\n"); break;
  1966.      default: myabort();
  1967.     }
  1968.     printf("\tint carry = val&1;\n");
  1969.     printf("\tcarry=val&1; val >>= 1;\n");
  1970.     genflags(flag_logical, table[opcode].size, "val", "", "");
  1971.     printf("regs.c = regs.x = carry!=0;\n");
  1972.     genastore("val", table[opcode].smode, "srcreg", table[opcode].size, "data");
  1973.     break;
  1974.      case i_LSLW:
  1975.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "data", true, false);
  1976.     start_brace ();
  1977.     switch(table[opcode].size) {
  1978.      case sz_byte: printf("\tUBYTE val = data;\n"); break;
  1979.      case sz_word: printf("\tUWORD val = data;\n"); break;
  1980.      case sz_long: printf("\tULONG val = data;\n"); break;
  1981.      default: myabort();
  1982.     }
  1983.     switch(table[opcode].size) {
  1984.      case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
  1985.      case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
  1986.      case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
  1987.      default: myabort();
  1988.     }
  1989.     printf("\tint carry = val&cmask;\n");
  1990.     printf("\tval <<= 1;\n");
  1991.     genflags(flag_logical, table[opcode].size, "val", "", "");
  1992.     printf("regs.c = regs.x = carry!=0;\n");
  1993.     genastore("val", table[opcode].smode, "srcreg", table[opcode].size, "data");
  1994.     break;
  1995.      case i_ROLW:
  1996.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "data", true, false);
  1997.     start_brace ();
  1998.     switch(table[opcode].size) {
  1999.      case sz_byte: printf("\tUBYTE val = data;\n"); break;
  2000.      case sz_word: printf("\tUWORD val = data;\n"); break;
  2001.      case sz_long: printf("\tULONG val = data;\n"); break;
  2002.      default: myabort();
  2003.     }
  2004.     switch(table[opcode].size) {
  2005.      case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
  2006.      case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
  2007.      case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
  2008.      default: myabort();
  2009.     }
  2010.     printf("\tint carry = val&cmask;\n");
  2011.     printf("\tval <<= 1;\n");
  2012.     printf("\tif(carry)  val |= 1;\n");
  2013.     genflags(flag_logical, table[opcode].size, "val", "", "");
  2014.     printf("regs.c = carry!=0;\n");
  2015.     genastore("val", table[opcode].smode, "srcreg", table[opcode].size, "data");
  2016.     break;
  2017.      case i_RORW:
  2018.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "data", true, false);
  2019.     start_brace ();
  2020.     switch(table[opcode].size) {
  2021.      case sz_byte: printf("\tUBYTE val = data;\n"); break;
  2022.      case sz_word: printf("\tUWORD val = data;\n"); break;
  2023.      case sz_long: printf("\tULONG val = data;\n"); break;
  2024.      default: myabort();
  2025.     }
  2026.     printf("\tint carry = val&1;\n");
  2027.     switch(table[opcode].size) {
  2028.      case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
  2029.      case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
  2030.      case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
  2031.      default: myabort();
  2032.     }
  2033.     printf("\tval >>= 1;\n");
  2034.     printf("\tif(carry) val |= cmask;\n");
  2035.     genflags(flag_logical, table[opcode].size, "val", "", "");
  2036.     printf("regs.c = carry!=0;\n");
  2037.     genastore("val", table[opcode].smode, "srcreg", table[opcode].size, "data");
  2038.     break;
  2039.      case i_ROXLW:
  2040.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "data", true, false);
  2041.     start_brace ();
  2042.     switch(table[opcode].size) {
  2043.      case sz_byte: printf("\tUBYTE val = data;\n"); break;
  2044.      case sz_word: printf("\tUWORD val = data;\n"); break;
  2045.      case sz_long: printf("\tULONG val = data;\n"); break;
  2046.      default: myabort();
  2047.     }
  2048.     switch(table[opcode].size) {
  2049.      case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
  2050.      case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
  2051.      case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
  2052.      default: myabort();
  2053.     }
  2054.     printf("\tint carry = val&cmask;\n");
  2055.     printf("\tval <<= 1;\n");
  2056.     printf("\tif(regs.x) val |= 1;\n");
  2057.     printf("\tregs.x = carry != 0;\n");
  2058.     genflags(flag_logical, table[opcode].size, "val", "", "");
  2059.     printf("regs.x = regs.c = carry!=0;\n");
  2060.     genastore("val", table[opcode].smode, "srcreg", table[opcode].size, "data");
  2061.     break;
  2062.      case i_ROXRW:
  2063.     genamode(table[opcode].smode, "srcreg", table[opcode].size, "data", true, false);
  2064.     start_brace ();
  2065.     switch(table[opcode].size) {
  2066.      case sz_byte: printf("\tUBYTE val = data;\n"); break;
  2067.      case sz_word: printf("\tUWORD val = data;\n"); break;
  2068.      case sz_long: printf("\tULONG val = data;\n"); break;
  2069.      default: myabort();
  2070.     }
  2071.     printf("\tint carry = val&1;\n");
  2072.     switch(table[opcode].size) {
  2073.      case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
  2074.      case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
  2075.      case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
  2076.      default: myabort();
  2077.     }
  2078.     printf("\tval >>= 1;\n");
  2079.     printf("\tif(regs.x) val |= cmask;\n");
  2080.     printf("\tregs.x = carry != 0;\n");
  2081.     genflags(flag_logical, table[opcode].size, "val", "", "");
  2082.     printf("regs.x = regs.c = carry!=0;\n");
  2083.     genastore("val", table[opcode].smode, "srcreg", table[opcode].size, "data");
  2084.     break;
  2085.      default:
  2086.     myabort();
  2087.     break;
  2088.     };
  2089.     finish_braces ();
  2090. }
  2091.  
  2092. static int mismatch;
  2093.  
  2094. static void handle_merges(long int opcode)
  2095. {
  2096.     UWORD smsk; 
  2097.     UWORD dmsk;
  2098.     int sbitsrc, sbitdst;
  2099.     int srcreg, dstreg;
  2100.     
  2101.     smsk = (table[opcode].sbtarg ? 255 : 7) << table[opcode].spos;
  2102.     dmsk = 7 << table[opcode].dpos;
  2103.     sbitsrc = table[opcode].spos == -1 ? 0 : 0;
  2104.     sbitdst = table[opcode].spos == -1 ? 1 : (table[opcode].sbtarg ? 256 : 8);
  2105.     for (srcreg=sbitsrc; srcreg < sbitdst; srcreg++) {
  2106.     for (dstreg=0; dstreg < (table[opcode].dpos == -1 ? 1 : 8); dstreg++) {
  2107.         UWORD code = opcode;        
  2108.  
  2109.         if (table[opcode].spos != -1) code &= ~(smsk << table[opcode].spos);
  2110.         if (table[opcode].dpos != -1) code &= ~(dmsk << table[opcode].dpos);
  2111.         
  2112.         if (table[opcode].spos != -1) code |= srcreg << table[opcode].spos;
  2113.         if (table[opcode].dpos != -1) code |= dstreg << table[opcode].dpos;
  2114.         
  2115.         /* Check whether this is in fact the same instruction.
  2116.          * The instructions should never differ, except for the
  2117.          * Bcc.(BW) case. */
  2118.         if (table[code].mnemo != table[opcode].mnemo
  2119.         || table[code].size != table[opcode].size
  2120.         || table[code].suse != table[opcode].suse
  2121.         || table[code].duse != table[opcode].duse) 
  2122.         {
  2123.         mismatch++; continue;
  2124.         }
  2125.         if (table[opcode].suse 
  2126.         && (table[opcode].spos != table[code].spos
  2127.             || table[opcode].smode != table[code].smode
  2128.             || table[opcode].sbtarg != table[code].sbtarg)) 
  2129.         {
  2130.         mismatch++; continue;
  2131.         }
  2132.         if (table[opcode].duse 
  2133.         && (table[opcode].dpos != table[code].dpos
  2134.             || table[opcode].dmode != table[code].dmode))
  2135.         {
  2136.         mismatch++; continue;
  2137.         }
  2138.         
  2139.         table[code].generated = true;
  2140.         table[code].handler = opcode;
  2141.     }
  2142.     }
  2143. }
  2144.            
  2145. static void generate_func(long int from, long int to)
  2146. {
  2147.     int illg = 0;
  2148.     long int opcode;
  2149.     UWORD smsk; 
  2150.     UWORD dmsk;    
  2151.     mismatch = 0;
  2152.  
  2153.     printf("#include <stdlib.h>\n");
  2154.     printf("#include \"config.h\"\n");
  2155.     printf("#include \"amiga.h\"\n");
  2156.     printf("#include \"options.h\"\n");
  2157.     printf("#include \"memory.h\"\n");
  2158.     printf("#include \"custom.h\"\n");    
  2159.     printf("#include \"newcpu.h\"\n");
  2160.     printf("#include \"cputbl.h\"\n");
  2161.     for(opcode=from; opcode < to; opcode++) {
  2162.     if (table[opcode].mnemo == i_ILLG) {
  2163.         illg++;
  2164.         continue;
  2165.     }
  2166.     if (table[opcode].generated) {
  2167.         continue;
  2168.     }
  2169. #ifndef HAVE_ONE_GIG_OF_MEMORY_TO_COMPILE_THIS
  2170.     
  2171.     handle_merges (opcode);
  2172.     
  2173.     smsk = (table[opcode].sbtarg ? 255 : 7) << table[opcode].spos;
  2174.     dmsk = 7 << table[opcode].dpos;
  2175.  
  2176.     printf("void op_%lx(UWORD opcode)\n{\n", opcode);
  2177.     if (table[opcode].suse
  2178.         && table[opcode].smode != imm  && table[opcode].smode != imm0
  2179.         && table[opcode].smode != imm1 && table[opcode].smode != imm2
  2180.         && table[opcode].smode != absw && table[opcode].smode != absl
  2181.         && table[opcode].smode != PC8r && table[opcode].smode != PC16)
  2182.     {
  2183.         if (table[opcode].spos == -1) {
  2184.         printf("\tULONG srcreg = %d;\n", (int)table[opcode].sreg);
  2185.         } else {
  2186.         printf("\tULONG srcreg = (LONG)(BYTE)((opcode & %d) >> %d);\n", smsk, (int)table[opcode].spos);
  2187.         }
  2188.     }
  2189.     if (table[opcode].duse
  2190.         /* Yes, the dmode can be imm, in case of LINK or DBcc */
  2191.         && table[opcode].dmode != imm  && table[opcode].dmode != imm0
  2192.         && table[opcode].dmode != imm1 && table[opcode].dmode != imm2
  2193.         && table[opcode].dmode != absw && table[opcode].dmode != absl) {
  2194.         if (table[opcode].dpos == -1) {        
  2195.         printf("\tULONG dstreg = %d;\n", (int)table[opcode].dreg);
  2196.         } else {
  2197.         printf("\tULONG dstreg = (opcode & %d) >> %d;\n", dmsk, (int)table[opcode].dpos);
  2198.         }
  2199.     }
  2200. #else
  2201.     printf("void op_%lx(UWORD opcode)\n{\n", opcode);
  2202.     if (table[opcode].suse)
  2203.         printf("\tULONG srcreg = %d;\n", (int)table[opcode].sreg);
  2204.     if (table[opcode].duse)
  2205.         printf("\tULONG dstreg = %d;\n", (int)table[opcode].dreg);
  2206. #endif
  2207.     gen_opcode(opcode);
  2208.         printf("}\n");
  2209.     }
  2210.  
  2211.     fprintf (stderr, "%d illegals generated.\n", illg);
  2212.     if (mismatch) fprintf(stderr, "%d mismatches.\n", mismatch);
  2213. }
  2214.  
  2215. static void generate_table(void)
  2216. {
  2217.     int illg = 0;
  2218.     long int opcode;
  2219.     
  2220.     mismatch = 0;
  2221.     
  2222.     printf("#include <stdlib.h>\n");
  2223.     printf("#include \"config.h\"\n");
  2224.     printf("#include \"amiga.h\"\n");
  2225.     printf("#include \"options.h\"\n");
  2226.     printf("#include \"memory.h\"\n");
  2227.     printf("#include \"custom.h\"\n");
  2228.     printf("#include \"newcpu.h\"\n");
  2229.     printf("#include \"cputbl.h\"\n");
  2230.     
  2231.     printf("cpuop_func *cpufunctbl[65536] = {\n");
  2232.     for(opcode=0; opcode < 65536; opcode++) {
  2233.     if (table[opcode].mnemo == i_ILLG) {
  2234.         printf("op_illg");
  2235.         illg++;
  2236.         goto loop_end;
  2237.     }
  2238.     if (table[opcode].generated) {
  2239.         printf("op_%x", table[opcode].handler);
  2240.         goto loop_end;
  2241.     }
  2242. #ifndef HAVE_ONE_GIG_OF_MEMORY_TO_COMPILE_THIS
  2243.     handle_merges (opcode);
  2244. #endif
  2245.     printf("op_%lx", opcode);
  2246.     
  2247.     loop_end:
  2248.     if (opcode < 65535) printf(",");
  2249.     if ((opcode & 7) == 7) printf("\n");
  2250.     }
  2251.     printf("\n};\n");
  2252.     fprintf (stderr, "%d illegals generated.\n", illg);
  2253.     if (mismatch) fprintf(stderr, "%d mismatches.\n", mismatch);
  2254. }
  2255.  
  2256. static void generate_header(void)
  2257. {
  2258.     int illg = 0;
  2259.     long int opcode;
  2260.     
  2261.     mismatch = 0;
  2262.     
  2263.     printf("extern void op_illg(UWORD) REGPARAM;\n");
  2264.     
  2265.     for(opcode=0; opcode < 65536; opcode++) {
  2266.     if (table[opcode].mnemo == i_ILLG) {
  2267.         illg++;
  2268.         continue;
  2269.     }
  2270.     if (table[opcode].generated) 
  2271.         continue;
  2272.         
  2273. #ifndef HAVE_ONE_GIG_OF_MEMORY_TO_COMPILE_THIS
  2274.     handle_merges (opcode);
  2275. #endif
  2276.     printf("extern cpuop_func op_%lx;\n", opcode);
  2277.     }
  2278.     
  2279.     fprintf (stderr, "%d illegals generated.\n", illg);
  2280.     if (mismatch) fprintf(stderr, "%d mismatches.\n", mismatch);
  2281. }
  2282.  
  2283. int main(int argc, char **argv)
  2284. {
  2285.     long int range = -1;
  2286.     char mode = 'n';
  2287.     int i;
  2288.     
  2289.     if (argc == 2)
  2290.         mode = *argv[1];
  2291.  
  2292.     if (argc == 3) {
  2293.     range = atoi(argv[2]);
  2294.     mode = *argv[1];
  2295.     }
  2296.     tablef = fopen("table68k","r");
  2297.     if (tablef == NULL) {
  2298.     fprintf(stderr, "table68k not found\n");
  2299.     exit(1);
  2300.     }
  2301.     table = (struct instr *) malloc (sizeof(struct instr) * 65536);
  2302.     for(i = 0; i < 65536; i++) {
  2303.     table[i].mnemo = i_ILLG;
  2304.     }
  2305.     getnextch();
  2306.     while (nextch != EOF) {
  2307.     get_bits();
  2308.     get_strs();
  2309.     parse_bits();
  2310.     }
  2311.     switch(mode) {
  2312.      case 'f':
  2313.         generate_func(range * 0x1000, (range + 1) * 0x1000);
  2314.     break;
  2315.      case 'h':
  2316.         generate_header();
  2317.     break;
  2318.      case 't':
  2319.     generate_table();
  2320.     break;
  2321.      default:
  2322.     myabort();
  2323.     }
  2324.     fclose(tablef);
  2325.     free(table);
  2326.     return 0;
  2327. }
  2328.